diff --git a/ChangeLog b/ChangeLog
index bae29a5..338b5fc 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,6 +1,13 @@
 
 === version history of distribution XML-Compile-SOAP
 
+version 3.28:
+
+	Improvements:
+	- require LWP::Potocol::https, because it is quite difficult to find-out
+	  that it missing is the cause of a failing installation.  People should
+	  use https in any case.  Suggested by [Balbino Matanzo]
+
 version 3.27: Wed  7 Apr 09:52:29 CEST 2021
 
 	Fixes:
diff --git a/MANIFEST b/MANIFEST
index 3ed569f..2326d48 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,7 +1,6 @@
 ChangeLog
 MANIFEST
 Makefile.PL
-README
 README.md
 TODO
 examples/document/README
@@ -22,42 +21,26 @@ examples/temperature/soap-lite.pl
 examples/temperature/xml-compile-soap.pl
 lib/XML/Compile/Operation.pm
 lib/XML/Compile/SOAP.pm
-lib/XML/Compile/SOAP.pod
 lib/XML/Compile/SOAP/Client.pm
-lib/XML/Compile/SOAP/Client.pod
 lib/XML/Compile/SOAP/Extension.pm
-lib/XML/Compile/SOAP/Extension.pod
 lib/XML/Compile/SOAP/FAQ.pod
 lib/XML/Compile/SOAP/Operation.pm
-lib/XML/Compile/SOAP/Operation.pod
 lib/XML/Compile/SOAP/Server.pm
-lib/XML/Compile/SOAP/Server.pod
 lib/XML/Compile/SOAP/Trace.pm
-lib/XML/Compile/SOAP/Trace.pod
 lib/XML/Compile/SOAP/Util.pm
-lib/XML/Compile/SOAP/Util.pod
 lib/XML/Compile/SOAP/xsd/xcdaemon/xcdaemon.xsd
 lib/XML/Compile/SOAP11.pm
-lib/XML/Compile/SOAP11.pod
 lib/XML/Compile/SOAP11/Client.pm
-lib/XML/Compile/SOAP11/Client.pod
 lib/XML/Compile/SOAP11/Encoding.pm
-lib/XML/Compile/SOAP11/Encoding.pod
 lib/XML/Compile/SOAP11/Operation.pm
-lib/XML/Compile/SOAP11/Operation.pod
 lib/XML/Compile/SOAP11/Server.pm
-lib/XML/Compile/SOAP11/Server.pod
 lib/XML/Compile/SOAP11/xsd/soap-encoding.xsd
 lib/XML/Compile/SOAP11/xsd/soap-envelope.xsd
 lib/XML/Compile/Transport.pm
-lib/XML/Compile/Transport.pod
 lib/XML/Compile/Transport/SOAPHTTP.pm
-lib/XML/Compile/Transport/SOAPHTTP.pod
 lib/XML/Compile/WSDL11/xsd/wsdl-soap.xsd
 lib/XML/Compile/XOP.pm
-lib/XML/Compile/XOP.pod
 lib/XML/Compile/XOP/Include.pm
-lib/XML/Compile/XOP/Include.pod
 lib/XML/Compile/XOP/xsd/200411-xmlmime.xsd
 lib/XML/Compile/XOP/xsd/200505-xmlmime.xsd
 t/01use.t
diff --git a/META.json b/META.json
index efcdac2..eabfd7e 100644
--- a/META.json
+++ b/META.json
@@ -4,7 +4,7 @@
       "Mark Overmeer <markov@cpan.org>"
    ],
    "dynamic_config" : 1,
-   "generated_by" : "ExtUtils::MakeMaker version 7.3, CPAN::Meta::Converter version 2.150010",
+   "generated_by" : "ExtUtils::MakeMaker version 7.62, CPAN::Meta::Converter version 2.150010",
    "license" : [
       "perl_5"
    ],
@@ -34,6 +34,7 @@
          "requires" : {
             "File::Slurper" : "0",
             "LWP" : "6.08",
+            "LWP::Protocol::https" : "6",
             "Log::Report" : "1.05",
             "Net::HTTP" : "6.16",
             "Test::More" : "0.54",
@@ -56,6 +57,6 @@
          "web" : "https://github.com/markov2/perl5-XML-Compile-SOAP"
       }
    },
-   "version" : "3.27",
-   "x_serialization_backend" : "JSON::PP version 2.94"
+   "version" : "3.28",
+   "x_serialization_backend" : "JSON::PP version 4.06"
 }
diff --git a/META.yml b/META.yml
index 415abc8..43f5a97 100644
--- a/META.yml
+++ b/META.yml
@@ -7,7 +7,7 @@ build_requires:
 configure_requires:
   ExtUtils::MakeMaker: '0'
 dynamic_config: 1
-generated_by: 'ExtUtils::MakeMaker version 7.3, CPAN::Meta::Converter version 2.150010'
+generated_by: 'ExtUtils::MakeMaker version 7.62, CPAN::Meta::Converter version 2.150010'
 license: perl
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
@@ -20,6 +20,7 @@ no_index:
 requires:
   File::Slurper: '0'
   LWP: '6.08'
+  LWP::Protocol::https: '6'
   Log::Report: '1.05'
   Net::HTTP: '6.16'
   Test::More: '0.54'
@@ -31,5 +32,5 @@ resources:
   homepage: http://perl.overmeer.net/CPAN/
   license: http://dev.perl.org/xml-compile/
   repository: https://github.com/markov2/perl5-XML-Compile-SOAP.git
-version: '3.27'
-x_serialization_backend: 'CPAN::Meta::YAML version 0.011'
+version: '3.28'
+x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
diff --git a/Makefile.PL b/Makefile.PL
index 1d1c06f..c991931 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -2,7 +2,7 @@ use ExtUtils::MakeMaker;
 
 use 5.010;
 
-my $version = '3.27';
+my $version = '3.28';
 
 my $prereq =
    { XML::Compile         => '1.58'
@@ -11,7 +11,8 @@ my $prereq =
    , Log::Report          => '1.05'
 
    , LWP               => 6.08
-   , Net::HTTP         => 6.16  # older versions contain nasty bugs
+   , LWP::Protocol::https => 6.00
+   , Net::HTTP         => 6.16  # older versions contains nasty bugs
    , Time::HiRes       => 0
    , File::Slurper     => 0
 
diff --git a/README b/README
deleted file mode 100644
index 07eacbb..0000000
--- a/README
+++ /dev/null
@@ -1,25 +0,0 @@
-=== README for XML-Compile-SOAP version 3.27
-=   Generated on Wed Apr  7 09:54:32 2021 by OODoc 2.02
-
-There are various ways to install this module:
-
- (1) if you have a command-line, you can do:
-       perl -MCPAN -e 'install <any package from this distribution>'
-
- (2) if you use Windows, have a look at http://ppm.activestate.com/
-
- (3) if you have downloaded this module manually (as root/administrator)
-       gzip -d XML-Compile-SOAP-3.27.tar.gz
-       tar -xf XML-Compile-SOAP-3.27.tar
-       cd XML-Compile-SOAP-3.27
-       perl Makefile.PL
-       make          # optional
-       make test     # optional
-       make install
-
-For usage, see the included manual-pages or
-    http://search.cpan.org/dist/XML-Compile-SOAP-3.27/
-
-Please report problems to
-    http://rt.cpan.org/Dist/Display.html?Queue=XML-Compile-SOAP
-
diff --git a/examples/document/has_schema.pl b/examples/document/has_schema.pl
old mode 100644
new mode 100755
diff --git a/examples/document/has_schema2.pl b/examples/document/has_schema2.pl
old mode 100644
new mode 100755
diff --git a/examples/document/has_wsdl.pl b/examples/document/has_wsdl.pl
old mode 100644
new mode 100755
diff --git a/examples/document/has_wsdl2.pl b/examples/document/has_wsdl2.pl
old mode 100644
new mode 100755
diff --git a/examples/rpc-literal/element.pl b/examples/rpc-literal/element.pl
old mode 100644
new mode 100755
diff --git a/examples/rpc-literal/type.pl b/examples/rpc-literal/type.pl
old mode 100644
new mode 100755
diff --git a/examples/temperature/soap-lite.pl b/examples/temperature/soap-lite.pl
old mode 100644
new mode 100755
diff --git a/examples/temperature/xml-compile-soap.pl b/examples/temperature/xml-compile-soap.pl
old mode 100644
new mode 100755
diff --git a/lib/XML/Compile/Operation.pm b/lib/XML/Compile/Operation.pm
index a25c3cf..8c7323c 100644
--- a/lib/XML/Compile/Operation.pm
+++ b/lib/XML/Compile/Operation.pm
@@ -1,7 +1,3 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 
    die "XML::Compile::Operation got renamed into XML::Compile::SOAP::Operation n release 2.18";
    1;
diff --git a/lib/XML/Compile/SOAP.pm b/lib/XML/Compile/SOAP.pm
index 55cbf77..2d38490 100644
--- a/lib/XML/Compile/SOAP.pm
+++ b/lib/XML/Compile/SOAP.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -30,6 +23,124 @@ use constant WSA10 => 'http://www.w3.org/2005/08/addressing';
 
 sub _xop_enabled() { exists $INC{'XML/Compile/XOP.pm'} }
 
+=chapter NAME
+XML::Compile::SOAP - base-class for SOAP implementations
+
+=chapter SYNOPSIS
+ ** SOAP1.[12] and WSDL1.1 over HTTP
+
+ # !!! The next steps are only required when you do not have
+ # !!! a WSDL. See XML::Compile::WSDL11 if you have a WSDL.
+ # !!! Without WSDL file, you need to do a lot manually
+
+ use XML::Compile::SOAP11::Client;
+ my $client = XML::Compile::SOAP11::Client->new;
+ $client->schemas->importDefinitions(...);
+
+ use XML::Compile::Util qw/pack_type/;
+ my $h1el = pack_type $myns, $some_element;
+ my $b1el = "{$myns}$other_element";  # same, less clean
+
+ my $encode_query = $client->compileMessage
+   ( 'SENDER'
+   , style    => 'document'           # default
+   , header   => [ h1 => $h1el ]
+   , body     => [ b1 => $b1el ]
+   , destination    => [ h1 => 'NEXT' ]
+   , mustUnderstand => 'h1'
+   );
+
+ my $decode_response = $client->compileMessage
+   ( 'RECEIVER'
+   , header   => [ h2 => $h2el ]
+   , body     => [ b2 => $b2el ]
+   , faults   => [ ... ]
+   );
+
+ my $transport = XML::Compile::Transport::SOAPHTTP
+    ->new(address => $server);
+ my $http = $transport->compileClient(action => ...);
+
+ my @query    = (h1 => ..., b1 => ...);
+ my $request  = $encode_query->(@query);
+ my ($response, $trace) = $http->($request);
+ my $answer   = $decode_response->($response);
+
+ use Data::Dumper;
+ warn Dumper $answer;     # discover a HASH with h2 and b2!
+
+ if($answer->{Fault}) ... # when an error was reported
+
+ # Simplify your life: combine above into one call
+ # Also in this case: if you have a WSDL, this is created
+ # for you.   $wsdl->compileClient('MyFirstCall');
+
+ my $call   = $client->compileClient
+   ( kind      => 'request-response'  # default
+   , name      => 'MyFirstCall'
+   , encode    => $encode_query
+   , decode    => $decode_response
+   , transport => $http
+   );
+
+ # !!! Usage, with or without WSDL file the same
+
+ my $result = $call->(@query)          # SCALAR only the result
+ print $result->{h2}->{...};
+ print $result->{b2}->{...};
+
+ my ($result, $trace) = $call->(...);  # LIST will show trace
+ # $trace is an XML::Compile::SOAP::Trace object
+
+=chapter DESCRIPTION
+
+This module handles the SOAP protocol.  The first implementation is
+SOAP1.1 (F<http://www.w3.org/TR/2000/NOTE-SOAP-20000508/>), which is still
+most often used.  The SOAP1.2 definition (F<http://www.w3.org/TR/soap12/>)
+is provided via the separate distribution M<XML::Compile::SOAP12>.
+
+Be aware that there are three kinds of SOAP:
+
+=over 4
+=item 1.
+Document style (literal) SOAP, where there is a WSDL file which explicitly
+types all out-going and incoming messages.  Very easy to use.
+
+=item 2.
+RPC style SOAP literal.  The body of the message has an extra element
+wrapper, but the content is also well defined.
+
+=item 3.
+RPC style SOAP encoded.  The sent data is nowhere described formally.
+The data is constructed in some ad-hoc way.
+=back
+
+Don't forget to have a look at the examples in the F<examples/> directory
+included in the distribution.
+
+Please support my development work by submitting bug-reports, patches
+and (if available) a donation.
+
+=chapter METHODS
+
+=section Constructors
+
+=method new %options
+Create a new SOAP object.  You have to instantiate either the SOAP11 or
+SOAP12 sub-class of this, because there are quite some differences (which
+can be hidden for you)
+
+=option  media_type MIMETYPE
+=default media_type C<application/soap+xml>
+
+=option  schemas    C<XML::Compile::Cache> object
+=default schemas    created internally
+Use this when you have already processed some schema definitions.  Otherwise,
+you can add schemas later with C<< $soap->schemas->importDefinitions() >>
+The Cache object must have C<any_element> and C<any_attribute> set to
+C<'ATTEMPT'>
+
+=cut
 
 sub new($@)
 {   my $class = shift;
@@ -64,6 +175,10 @@ sub _initSOAP($)
     $thing;
 }
 
+=c_method register $uri, $envns
+Declare an operation type, being an (WSDL specific) $uri and envelope
+namespace.
+=cut
 
 {   my (%registered, %envelope);
     sub register($)
@@ -77,10 +192,18 @@ sub _initSOAP($)
 }
 
 #--------------------
+=section Accessors
+=method version 
+=method mediaType 
+=cut
 
 sub version()   {panic "not implemented"}
 sub mediaType() {shift->{XCS_mime}}
 
+=method schemas 
+Returns the M<XML::Compile::Cache> object which contains the
+knowledge about the types.
+=cut
 
 sub schemas() {
 use Carp 'cluck';
@@ -88,6 +211,90 @@ ref $_[0] or cluck;
 shift->{XCS_schemas}}
 
 #--------------------
+=section Single message
+
+=method compileMessage <'SENDER'|'RECEIVER'>, %options
+The payload is defined explicitly, where all headers and bodies are
+described in detail.  When you have a WSDL file, these ENTRIES are
+generated automatically, but can be modified and extended (WSDL files
+are often incomplete)
+
+To make your life easy, the ENTRIES use a label (a free to choose key,
+the I<part name> in WSDL terminology), to ease relation of your data with
+the type where it belongs to.  The element of an entry (the value) is
+defined as an C<any> element in the schema, and therefore you will need
+to explicitly specify the element to be processed.
+
+As %options, you can specify any listed here, but also anything which is
+accepted by M<XML::Compile::Schema::compile()>, like
+C<< sloppy_integers => 1 >> and hooks.  These are applied to all header
+and body elements (not to the SOAP wrappers)
+
+=option  header ENTRIES|HASH
+=default header C<undef>
+ARRAY of PAIRS, defining a nice LABEL (free of choice but unique)
+and an element type name.  The LABEL will appear in the Perl HASH, to
+refer to the element in a simple way.
+
+The element type is used to construct a reader or writer.  You may also
+create your own reader or writer, and then pass a compatible CODE reference.
+
+=option  body   ENTRIES|HASH
+=default body   []
+ARRAY of PAIRS, defining a nice LABEL (free of choice but unique, also
+w.r.t. the header and fault ENTRIES) and an element type name or CODE
+reference.  The LABEL will appear in the Perl HASH only, to be able to
+refer to a body element in a simple way.
+
+=option  procedure TYPE
+=default procedure C<undef>
+Required in rpc style, when there is no C<body> which contains the
+procedure name (when the RPC info does not come from a WSDL)
+
+=option  faults ENTRIES|HASH
+=default faults []
+The SOAP1.1 and SOAP1.2 protocols define fault entries in the
+answer.  Both have a location to add your own additional
+information: the type(-processor) is to specified here, but the
+returned information structure is larger and differs per SOAP
+implementation.
+
+=option  mustUnderstand STRING|ARRAY-OF-STRING
+=default mustUnderstand []
+Writers only.  The specified header entry labels specify which elements
+must be understood by the destination.  These elements will get the
+C<mustUnderstand> attribute set to C<1> (soap1.1) or C<true> (soap1.2).
+
+=option  destination ARRAY-OF-PAIRS
+=default destination []
+Writers only.  Indicate who the target of the header entry is.
+By default, the end-point is the destination of each header element.
+
+The ARRAY contains a LIST of key-value pairs, specifying an entry label
+followed by an I<actor> (soap1.1) or I<role> (soap1.2) URI.  You may use
+the predefined actors/roles, like 'NEXT'.  See M<roleURI()> and
+M<roleAbbreviation()>.
+
+=option  role URI|ARRAY-OF-URI
+=default role C<ULTIMATE>
+Readers only.
+One or more URIs, specifying the role(s) you application has in the
+process.  Only when your role contains C<ULTIMATE>, the body is
+parsed.  Otherwise, the body is returned as uninterpreted XML tree.
+You should not use the role C<NEXT>, because every intermediate
+node is a C<NEXT>.
+
+All understood headers are parsed when the C<actor> (soap1.1) or
+C<role> (soap1.2) attribute address the specified URI.  When other
+headers emerge which are not understood but carry the C<mustUnderstood>
+attribute, an fault is returned automatically.  In that case, the
+call to the compiled subroutine will return C<undef>.
+
+=option  roles ARRAY-OF-URI
+=default roles []
+Alternative for option C<role>
+
+=cut
 
 sub compileMessage($@)
 {   my ($self, $direction, %args) = @_;
@@ -99,6 +306,12 @@ sub compileMessage($@)
          , dir => $direction;
 }
 
+=ci_method messageStructure $xml
+Returns a HASH with some collected information from a complete SOAP
+message (XML::LibXML::Document or XML::LibXML::Element).  Currenty,
+the HASH contains a C<header> and a C<body> key, with each an ARRAY
+of element names which where found in the header resp. body.
+=cut
 
 sub messageStructure($)
 {   my ($thing, $xml) = @_;
@@ -666,16 +879,182 @@ sub _writer(@) { shift->schemas->writer(@_) }
 
 #------------------------------------------------
 
+=section Helpers
+
+=section Transcoding
+
+=method roleURI $uri|STRING
+Translates actor/role/destination abbreviations into URIs. Various
+SOAP protocol versions have different pre-defined STRINGs, which can
+be abbreviated for readibility.  Returns the unmodified $uri in
+all other cases.
+
+SOAP11 only defines C<NEXT>.  SOAP12 defines C<NEXT>, C<NONE>, and
+C<ULTIMATE>.
+=cut
 
 sub roleURI($) { panic "not implemented" }
 
+=method roleAbbreviation $uri
+Translate a role $uri into a simple string, if predefined.  See
+M<roleURI()>.
+=cut
 
 sub roleAbbreviation($) { panic "not implemented" }
 
+=method replyMustUnderstandFault $type
+Produce an error structure to be returned to the sender.
+=cut
 
 sub replyMustUnderstandFault($) { panic "not implemented" }
 
 #----------------------
 
+=chapter DETAILS
+
+=section SOAP introduction
+
+Although the specifications of SOAP1.1 and WSDL1.1 are thin, the number
+of special constructs are many. And, of course, all are poorly documented.
+SOAP 1.2 has a much better specification, but is not used a lot.  I have
+not seen WSDL2 in real life.
+
+WSDL defines two kinds of messages: B<document> style SOAP and B<rpc>
+style SOAP.  In document style SOAP, the messages are described in
+great detail in the WSDL: the message components are all defined in
+Schema's. The worst things you can (will) encounter are C<any> schema
+elements which require additional manual processing.
+
+C<RPC Literal> behaves very much the same way as document style soap,
+but has one extra wrapper inside the Body of the message.
+
+C<Encoded SOAP-RPC>, however, is a very different ball-game.  It is simple
+to use with strongly typed languages, to exchange data when you create both
+the client software and the server software.  You can simply autogenerate
+the data encoding.  Clients written by third parties have to find the
+documentation on how to use the encoded  RPC call in some other way... in
+text, if they are lucky; the WSDL file does not contain the prototype
+of the procedures, but that doesn't mean that they are free-format.
+
+B<Encoded RPC> messages are shaped to the procedures which are
+being called on the server.  The body of the sent message contains the
+ordered list of parameters to be passed as 'in' and 'in/out' values to the
+remote procedure.  The body of the returned message lists the result value
+of the procedure, followed by the ordered 'out' and 'in/out' parameters.
+
+=section Supported servers
+
+Only the commercial hype speaks about SOAP in very positive words.
+However, the "industry quality" of these modern "technologies" clearly
+demonstrates the lack of education and experience most programmers and
+designers have.  This is clearly visible in many, many bugs you will
+encounter when working with schemas and WSDLs.
+
+Interoperability of SOAP clients and servers is more "trial and error"
+and "manually fixing" than it should be.  For instance, a server may
+report internal server errors back to the client... but a WSDL does not
+tell you which namespace/schema is used for these errors.  Both BEA and
+SharePoint servers produce illegal SOAP responses!  It is a sad story.
+
+To be able to install some fixes, you can specify a server type via
+M<XML::Compile::SOAP::Operation::new(server_type)>,
+M<XML::Compile::WSDL11::new(server_type)>, or
+[3.06] M<XML::Compile::WSDL11::operations(server_type)>.
+
+The following server types are currently understood:
+
+=over 4
+=item * C<BEA>, Oracle
+=item * C<SharePoint>, MicroSoft
+=item * C<XML::Compile::Daemon>
+=back
+
+Examples:
+
+  my $wsdl = XML::Compile::WSDL11->new($wsdlfn, server_type => 'SharePoint');
+  my $op   = XML::Compile::SOAP11::Operation->new(..., server_type => 'BEA');
+  my @op   = XML::Compile::WSDL11->operations(server_type => 'SharePoint')
+
+[3.17] B<Be warned:> the licenses of some server_type schema's are unknown
+or unclear.  At least, they touch commercial products hence can better
+not be released in a (Debian) Linux distribution, even not as non-free.
+Therefore, you need to install M<XML::Compile::Licensed> from CPAN
+yourself.
+
+=section Naming types and elements
+
+XML uses namespaces: URIs which are used as constants, grouping a set
+of type and element definitions.  By using name-spaces, you can avoid
+name clashes, which have frustrated many projects in the past when they
+grew over a certain size... at a certain size, it becomes too hard to
+think of good distinguishable names.  In such case, you must be happy
+when you can place those names in a context, and use the same naming in
+separate contexts without confusion.
+
+That being said: XML supports both namespace- and non-namespace elements
+and schema's; and of cause many mixed cases.  It is by far preferred to
+use namespace schemas only. In a schema XSD file, look for the
+C<targetNamespace> attribute of the C<schema> element: if present, it
+uses namespaces.
+
+In XML data, it is seen as a hassle to write the full length of the URI
+each time that a namespace is addressed.  For this reason, prefixes are
+used as abbreviations for the namespace URI.  In programs, you can simply
+assign short variable names to long URIs, so we do not need that trick.
+
+Within your program, you use
+
+  $MYNS = 'long URI of namespace';
+  ... $type => "{$MYNS}typename" ...
+
+or nicer
+
+  use XML::Compile::Util qw/pack_type/;
+  use constant MYNS => 'some uri';
+  ... $type => pack_type(MYNS, 'typename') ...
+
+The M<XML::Compile::Util> module provides a helpful methods and constants,
+as does the M<XML::Compile::SOAP::Util>.
+
+=section Client and Server implementations
+
+To learn how to create clients in SOAP, read the DETAILS section in
+M<XML::Compile::SOAP::Client>.  The client implementation is platform
+independent.
+
+Servers can be created with the external M<XML::Compile::SOAP::Daemon>
+distribution. Those servers are based on M<Net::Server>. Can be used
+to create a test-server in a few minutes... or production server.
+
+Don't forget to have a look at the examples in the F<examples/> directory
+included in the distribution.
+
+=section Use of wildcards (any and anyAttribute)
+
+Start reading about wildcards in M<XML::Compile>. When you receive a
+message which contains "ANY" elements, an attempt will be made to decode
+it automatically. Sending messages which contain "ANY" fields is
+harder... you may try hooks or something more along these lines:
+
+   my $doc = XML::LibXML::Document->new('1.0', 'UTF-8');
+   my $type    = pack_type $ns, $local;
+   my $node    = $wsdl->writer($type)->($doc, $value);
+   my $message = { ..., $type => $node };
+
+   my $call = $wsdl->compileClient('myOpToCall');
+   my ($answer, $trace) = $call->(_doc => $doc, message => $message);
+
+Here, C<$type> is the type of the element which needs to be filled in
+on a spot where the schema defines an "ANY" element. You need to include
+the full typename as key in the HASH (on the right spot) and a fully
+prepared C<$node>, an M<XML::LibXML::Element>, as the value.
+
+You see that the C<$doc> which is created to produce the special node
+in the message is also passed to the C<$call>. The call produces the
+message which is sent and needs to use the same document object as the
+node inside it. The chances are that when you forget to pass the C<$doc>
+it still works... but you may get into characterset problems and such.
+
+=cut
 
 1;
diff --git a/lib/XML/Compile/SOAP.pod b/lib/XML/Compile/SOAP.pod
deleted file mode 100644
index 43ae7e3..0000000
--- a/lib/XML/Compile/SOAP.pod
+++ /dev/null
@@ -1,464 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP - base-class for SOAP implementations
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP is extended by
-   XML::Compile::SOAP11
-   XML::Compile::SOAP12
-
-=head1 SYNOPSIS
-
- ** SOAP1.[12] and WSDL1.1 over HTTP
-
- # !!! The next steps are only required when you do not have
- # !!! a WSDL. See XML::Compile::WSDL11 if you have a WSDL.
- # !!! Without WSDL file, you need to do a lot manually
-
- use XML::Compile::SOAP11::Client;
- my $client = XML::Compile::SOAP11::Client->new;
- $client->schemas->importDefinitions(...);
-
- use XML::Compile::Util qw/pack_type/;
- my $h1el = pack_type $myns, $some_element;
- my $b1el = "{$myns}$other_element";  # same, less clean
-
- my $encode_query = $client->compileMessage
-   ( 'SENDER'
-   , style    => 'document'           # default
-   , header   => [ h1 => $h1el ]
-   , body     => [ b1 => $b1el ]
-   , destination    => [ h1 => 'NEXT' ]
-   , mustUnderstand => 'h1'
-   );
-
- my $decode_response = $client->compileMessage
-   ( 'RECEIVER'
-   , header   => [ h2 => $h2el ]
-   , body     => [ b2 => $b2el ]
-   , faults   => [ ... ]
-   );
-
- my $transport = XML::Compile::Transport::SOAPHTTP
-    ->new(address => $server);
- my $http = $transport->compileClient(action => ...);
-
- my @query    = (h1 => ..., b1 => ...);
- my $request  = $encode_query->(@query);
- my ($response, $trace) = $http->($request);
- my $answer   = $decode_response->($response);
-
- use Data::Dumper;
- warn Dumper $answer;     # discover a HASH with h2 and b2!
-
- if($answer->{Fault}) ... # when an error was reported
-
- # Simplify your life: combine above into one call
- # Also in this case: if you have a WSDL, this is created
- # for you.   $wsdl->compileClient('MyFirstCall');
-
- my $call   = $client->compileClient
-   ( kind      => 'request-response'  # default
-   , name      => 'MyFirstCall'
-   , encode    => $encode_query
-   , decode    => $decode_response
-   , transport => $http
-   );
-
- # !!! Usage, with or without WSDL file the same
-
- my $result = $call->(@query)          # SCALAR only the result
- print $result->{h2}->{...};
- print $result->{b2}->{...};
-
- my ($result, $trace) = $call->(...);  # LIST will show trace
- # $trace is an XML::Compile::SOAP::Trace object
-
-=head1 DESCRIPTION
-
-This module handles the SOAP protocol.  The first implementation is
-SOAP1.1 (F<http://www.w3.org/TR/2000/NOTE-SOAP-20000508/>), which is still
-most often used.  The SOAP1.2 definition (F<http://www.w3.org/TR/soap12/>)
-is provided via the separate distribution L<XML::Compile::SOAP12|XML::Compile::SOAP12>.
-
-Be aware that there are three kinds of SOAP:
-
-=over 4
-
-=item 1.
-
-Document style (literal) SOAP, where there is a WSDL file which explicitly
-types all out-going and incoming messages.  Very easy to use.
-
-=item 2.
-
-RPC style SOAP literal.  The body of the message has an extra element
-wrapper, but the content is also well defined.
-
-=item 3.
-
-RPC style SOAP encoded.  The sent data is nowhere described formally.
-The data is constructed in some ad-hoc way.
-
-=back
-
-Don't forget to have a look at the examples in the F<examples/> directory
-included in the distribution.
-
-Please support my development work by submitting bug-reports, patches
-and (if available) a donation.
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item $obj-E<gt>B<new>(%options)
-
-Create a new SOAP object.  You have to instantiate either the SOAP11 or
-SOAP12 sub-class of this, because there are quite some differences (which
-can be hidden for you)
-
- -Option    --Default
-  media_type  application/soap+xml
-  schemas     created internally
-
-=over 2
-
-=item media_type => MIMETYPE
-
-=item schemas => C<XML::Compile::Cache> object
-
-Use this when you have already processed some schema definitions.  Otherwise,
-you can add schemas later with C<< $soap->schemas->importDefinitions() >>
-The Cache object must have C<any_element> and C<any_attribute> set to
-C<'ATTEMPT'>
-
-=back
-
-=item XML::Compile::SOAP-E<gt>B<register>($uri, $envns)
-
-Declare an operation type, being an (WSDL specific) $uri and envelope
-namespace.
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<mediaType>()
-
-=item $obj-E<gt>B<schemas>()
-
-Returns the L<XML::Compile::Cache|XML::Compile::Cache> object which contains the
-knowledge about the types.
-
-=item $obj-E<gt>B<version>()
-
-=back
-
-=head2 Single message
-
-=over 4
-
-=item $obj-E<gt>B<compileMessage>( <'SENDER'|'RECEIVER'>, %options )
-
-The payload is defined explicitly, where all headers and bodies are
-described in detail.  When you have a WSDL file, these ENTRIES are
-generated automatically, but can be modified and extended (WSDL files
-are often incomplete)
-
-To make your life easy, the ENTRIES use a label (a free to choose key,
-the I<part name> in WSDL terminology), to ease relation of your data with
-the type where it belongs to.  The element of an entry (the value) is
-defined as an C<any> element in the schema, and therefore you will need
-to explicitly specify the element to be processed.
-
-As %options, you can specify any listed here, but also anything which is
-accepted by L<XML::Compile::Schema::compile()|XML::Compile::Schema/"Compilers">, like
-C<< sloppy_integers => 1 >> and hooks.  These are applied to all header
-and body elements (not to the SOAP wrappers)
-
- -Option        --Default
-  body            []
-  destination     []
-  faults          []
-  header          undef
-  mustUnderstand  []
-  procedure       undef
-  role            ULTIMATE
-  roles           []
-
-=over 2
-
-=item body => ENTRIES|HASH
-
-ARRAY of PAIRS, defining a nice LABEL (free of choice but unique, also
-w.r.t. the header and fault ENTRIES) and an element type name or CODE
-reference.  The LABEL will appear in the Perl HASH only, to be able to
-refer to a body element in a simple way.
-
-=item destination => ARRAY-OF-PAIRS
-
-Writers only.  Indicate who the target of the header entry is.
-By default, the end-point is the destination of each header element.
-
-The ARRAY contains a LIST of key-value pairs, specifying an entry label
-followed by an I<actor> (soap1.1) or I<role> (soap1.2) URI.  You may use
-the predefined actors/roles, like 'NEXT'.  See L<roleURI()|XML::Compile::SOAP/"Transcoding"> and
-L<roleAbbreviation()|XML::Compile::SOAP/"Transcoding">.
-
-=item faults => ENTRIES|HASH
-
-The SOAP1.1 and SOAP1.2 protocols define fault entries in the
-answer.  Both have a location to add your own additional
-information: the type(-processor) is to specified here, but the
-returned information structure is larger and differs per SOAP
-implementation.
-
-=item header => ENTRIES|HASH
-
-ARRAY of PAIRS, defining a nice LABEL (free of choice but unique)
-and an element type name.  The LABEL will appear in the Perl HASH, to
-refer to the element in a simple way.
-
-The element type is used to construct a reader or writer.  You may also
-create your own reader or writer, and then pass a compatible CODE reference.
-
-=item mustUnderstand => STRING|ARRAY-OF-STRING
-
-Writers only.  The specified header entry labels specify which elements
-must be understood by the destination.  These elements will get the
-C<mustUnderstand> attribute set to C<1> (soap1.1) or C<true> (soap1.2).
-
-=item procedure => TYPE
-
-Required in rpc style, when there is no C<body> which contains the
-procedure name (when the RPC info does not come from a WSDL)
-
-=item role => URI|ARRAY-OF-URI
-
-Readers only.
-One or more URIs, specifying the role(s) you application has in the
-process.  Only when your role contains C<ULTIMATE>, the body is
-parsed.  Otherwise, the body is returned as uninterpreted XML tree.
-You should not use the role C<NEXT>, because every intermediate
-node is a C<NEXT>.
-
-All understood headers are parsed when the C<actor> (soap1.1) or
-C<role> (soap1.2) attribute address the specified URI.  When other
-headers emerge which are not understood but carry the C<mustUnderstood>
-attribute, an fault is returned automatically.  In that case, the
-call to the compiled subroutine will return C<undef>.
-
-=item roles => ARRAY-OF-URI
-
-Alternative for option C<role>
-
-=back
-
-=item $obj-E<gt>B<messageStructure>($xml)
-
-=item XML::Compile::SOAP-E<gt>B<messageStructure>($xml)
-
-Returns a HASH with some collected information from a complete SOAP
-message (XML::LibXML::Document or XML::LibXML::Element).  Currenty,
-the HASH contains a C<header> and a C<body> key, with each an ARRAY
-of element names which where found in the header resp. body.
-
-=back
-
-=head2 Helpers
-
-=head2 Transcoding
-
-=over 4
-
-=item $obj-E<gt>B<replyMustUnderstandFault>($type)
-
-Produce an error structure to be returned to the sender.
-
-=item $obj-E<gt>B<roleAbbreviation>($uri)
-
-Translate a role $uri into a simple string, if predefined.  See
-L<roleURI()|XML::Compile::SOAP/"Transcoding">.
-
-=item $obj-E<gt>B<roleURI>($uri|STRING)
-
-Translates actor/role/destination abbreviations into URIs. Various
-SOAP protocol versions have different pre-defined STRINGs, which can
-be abbreviated for readibility.  Returns the unmodified $uri in
-all other cases.
-
-SOAP11 only defines C<NEXT>.  SOAP12 defines C<NEXT>, C<NONE>, and
-C<ULTIMATE>.
-
-=back
-
-=head1 DETAILS
-
-=head2 SOAP introduction
-
-Although the specifications of SOAP1.1 and WSDL1.1 are thin, the number
-of special constructs are many. And, of course, all are poorly documented.
-SOAP 1.2 has a much better specification, but is not used a lot.  I have
-not seen WSDL2 in real life.
-
-WSDL defines two kinds of messages: B<document> style SOAP and B<rpc>
-style SOAP.  In document style SOAP, the messages are described in
-great detail in the WSDL: the message components are all defined in
-Schema's. The worst things you can (will) encounter are C<any> schema
-elements which require additional manual processing.
-
-C<RPC Literal> behaves very much the same way as document style soap,
-but has one extra wrapper inside the Body of the message.
-
-C<Encoded SOAP-RPC>, however, is a very different ball-game.  It is simple
-to use with strongly typed languages, to exchange data when you create both
-the client software and the server software.  You can simply autogenerate
-the data encoding.  Clients written by third parties have to find the
-documentation on how to use the encoded  RPC call in some other way... in
-text, if they are lucky; the WSDL file does not contain the prototype
-of the procedures, but that doesn't mean that they are free-format.
-
-B<Encoded RPC> messages are shaped to the procedures which are
-being called on the server.  The body of the sent message contains the
-ordered list of parameters to be passed as 'in' and 'in/out' values to the
-remote procedure.  The body of the returned message lists the result value
-of the procedure, followed by the ordered 'out' and 'in/out' parameters.
-
-=head2 Supported servers
-
-Only the commercial hype speaks about SOAP in very positive words.
-However, the "industry quality" of these modern "technologies" clearly
-demonstrates the lack of education and experience most programmers and
-designers have.  This is clearly visible in many, many bugs you will
-encounter when working with schemas and WSDLs.
-
-Interoperability of SOAP clients and servers is more "trial and error"
-and "manually fixing" than it should be.  For instance, a server may
-report internal server errors back to the client... but a WSDL does not
-tell you which namespace/schema is used for these errors.  Both BEA and
-SharePoint servers produce illegal SOAP responses!  It is a sad story.
-
-To be able to install some fixes, you can specify a server type via
-L<XML::Compile::SOAP::Operation::new(server_type)|XML::Compile::SOAP::Operation/"Constructors">,
-L<XML::Compile::WSDL11::new(server_type)|XML::Compile::WSDL11/"Constructors">, or
-[3.06] L<XML::Compile::WSDL11::operations(server_type)|XML::Compile::WSDL11/"Introspection">.
-
-The following server types are currently understood:
-
-=over 4
-
-=item * C<BEA>, Oracle
-
-=item * C<SharePoint>, MicroSoft
-
-=item * C<XML::Compile::Daemon>
-
-=back
-
-Examples:
-
-  my $wsdl = XML::Compile::WSDL11->new($wsdlfn, server_type => 'SharePoint');
-  my $op   = XML::Compile::SOAP11::Operation->new(..., server_type => 'BEA');
-  my @op   = XML::Compile::WSDL11->operations(server_type => 'SharePoint')
-
-[3.17] B<Be warned:> the licenses of some server_type schema's are unknown
-or unclear.  At least, they touch commercial products hence can better
-not be released in a (Debian) Linux distribution, even not as non-free.
-Therefore, you need to install XML::Compile::Licensed from CPAN
-yourself.
-
-=head2 Naming types and elements
-
-XML uses namespaces: URIs which are used as constants, grouping a set
-of type and element definitions.  By using name-spaces, you can avoid
-name clashes, which have frustrated many projects in the past when they
-grew over a certain size... at a certain size, it becomes too hard to
-think of good distinguishable names.  In such case, you must be happy
-when you can place those names in a context, and use the same naming in
-separate contexts without confusion.
-
-That being said: XML supports both namespace- and non-namespace elements
-and schema's; and of cause many mixed cases.  It is by far preferred to
-use namespace schemas only. In a schema XSD file, look for the
-C<targetNamespace> attribute of the C<schema> element: if present, it
-uses namespaces.
-
-In XML data, it is seen as a hassle to write the full length of the URI
-each time that a namespace is addressed.  For this reason, prefixes are
-used as abbreviations for the namespace URI.  In programs, you can simply
-assign short variable names to long URIs, so we do not need that trick.
-
-Within your program, you use
-
-  $MYNS = 'long URI of namespace';
-  ... $type => "{$MYNS}typename" ...
-
-or nicer
-
-  use XML::Compile::Util qw/pack_type/;
-  use constant MYNS => 'some uri';
-  ... $type => pack_type(MYNS, 'typename') ...
-
-The L<XML::Compile::Util|XML::Compile::Util> module provides a helpful methods and constants,
-as does the L<XML::Compile::SOAP::Util|XML::Compile::SOAP::Util>.
-
-=head2 Client and Server implementations
-
-To learn how to create clients in SOAP, read the DETAILS section in
-L<XML::Compile::SOAP::Client|XML::Compile::SOAP::Client>.  The client implementation is platform
-independent.
-
-Servers can be created with the external L<XML::Compile::SOAP::Daemon|XML::Compile::SOAP::Daemon>
-distribution. Those servers are based on Net::Server. Can be used
-to create a test-server in a few minutes... or production server.
-
-Don't forget to have a look at the examples in the F<examples/> directory
-included in the distribution.
-
-=head2 Use of wildcards (any and anyAttribute)
-
-Start reading about wildcards in L<XML::Compile|XML::Compile>. When you receive a
-message which contains "ANY" elements, an attempt will be made to decode
-it automatically. Sending messages which contain "ANY" fields is
-harder... you may try hooks or something more along these lines:
-
-   my $doc = XML::LibXML::Document->new('1.0', 'UTF-8');
-   my $type    = pack_type $ns, $local;
-   my $node    = $wsdl->writer($type)->($doc, $value);
-   my $message = { ..., $type => $node };
-
-   my $call = $wsdl->compileClient('myOpToCall');
-   my ($answer, $trace) = $call->(_doc => $doc, message => $message);
-
-Here, C<$type> is the type of the element which needs to be filled in
-on a spot where the schema defines an "ANY" element. You need to include
-the full typename as key in the HASH (on the right spot) and a fully
-prepared C<$node>, an XML::LibXML::Element, as the value.
-
-You see that the C<$doc> which is created to produce the special node
-in the message is also passed to the C<$call>. The call produces the
-message which is sent and needs to use the same document object as the
-node inside it. The chances are that when you forget to pass the C<$doc>
-it still works... but you may get into characterset problems and such.
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Client.pm b/lib/XML/Compile/SOAP/Client.pm
index 60172da..ee7c1b9 100644
--- a/lib/XML/Compile/SOAP/Client.pm
+++ b/lib/XML/Compile/SOAP/Client.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Client;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -20,11 +13,90 @@ use XML::Compile::Util qw/unpack_type/;
 use XML::Compile::SOAP::Trace;
 use Time::HiRes        qw/time/;
 
+=chapter NAME
+XML::Compile::SOAP::Client - SOAP message initiators
+
+=chapter SYNOPSIS
+ # never used directly, only via XML::Compile::SOAP1[12]::Client
+
+=chapter DESCRIPTION
+This class defines the methods that each client side of the SOAP
+message exchange protocols must implement.
+
+=chapter METHODS
+
+=section Constructors
+This object can not be instantiated, but is only used as secundary
+base class.  The primary must contain the C<new>.
+=cut
 
 sub new(@) { panic __PACKAGE__." only secundary in multiple inheritance" }
 sub init($) { shift }
 
 #--------------
+=section Handlers
+
+=method compileClient %options
+
+=option  name STRING
+=default name <undef>
+
+=option  kind STRING
+=default kind C<request-response>
+Which kind of client is this.  WSDL11 defines four kinds of client-server
+interaction.  Only C<request-response> (the default) and C<one-way> are
+currently supported.
+
+=requires encode CODE
+The CODE reference is produced by M<XML::Compile::SOAP::compileMessage()>,
+and must be a SENDER: translates Perl data structures into the SOAP
+message in XML.
+
+=requires decode CODE
+The CODE reference is produced by M<XML::Compile::SOAP::compileMessage()>,
+and must be a RECEIVER: translate a SOAP message into Perl data.  Even in
+one-way operation, this decode should be provided: some servers may pass
+back some XML in case of errors.
+
+=requires transport CODE|OBJECT
+The CODE reference is produced by an extensions of
+M<XML::Compile::Transport::compileClient()> (usually
+M<XML::Compile::Transport::SOAPHTTP::compileClient()>.
+
+If you pass a M<XML::Compile::Transport::SOAPHTTP> object, the
+compileClient will be called for you.  This is possible in case you do
+not have any configuration options to pass with the compileClient().
+
+=option  soap OBJECT|'SOAP11'|'SOAP12'
+=default soap 'SOAP11'
+When the transport parameter is an object, this is used to wrap the
+SOAP content according to the matching transporter regulation.
+
+=option  async BOOLEAN
+=default async <false>
+If true, a whole different code-reference is returned. Each time it
+is called, the call will be made but the function returns immediately.
+As additional parameter to the call, you must provide a C<_callback>
+parameter which is a code-reference which will handle the result.
+
+=example
+
+Normal call:
+
+   my $call = $wsdl->compileClient('myOp');
+   my ($answer, $trace) = $call->(@params);
+   #do something with $answer
+
+Async call:
+
+   my $call = $wsdl->compileClient('myOp', async => 1);
+   sub cb
+   {  my ($answer, $trace) = @_;
+      #do something with $answer
+   };
+   $call->(@params, _callback => \&cb);
+
+=cut
 
 my $rr = 'request-response';
 
@@ -124,5 +196,381 @@ sub compileClient(@)
 
 #------------------------------------------------
 
+=chapter DETAILS
+
+=section Client side SOAP
+
+=subsection Calling the server (Document style)
+
+First, you compile the call either via a WSDL file (see
+M<XML::Compile::WSDL11>), or in a few manual steps (which are described
+in the next section).  In either way, you end-up with a CODE references
+which can be called multiple times.
+
+    # compile once
+    my $call   = $soap->compileClient(...);
+
+    # and call often
+    my $answer = $call->(%request);  # list of pairs
+    my $answer = $call->(\%request); # same, but HASH
+    my $answer = $call->(\%request, 'UTF-8');  # same
+
+    # or with trace details, see XML::Compile::SOAP::Trace
+    my ($answer, $trace) = $call->...
+
+But what is the structure of C<%request> and C<$answer>?  Well, there
+are various syntaxes possible: from structurally perfect, to user-friendly.
+
+First, find out which data structures can be present: when you compiled
+your messages explicitly, you have picked your own names.  When the
+call was initiated from a WSDL file, then you have to find the names of
+the message parts which can be used: the part names for header blocks,
+body blocks, headerfaults, and (body) faults.  Do not worry to much,
+you will get (hopefully understandable) run-time error messages when
+the structure is incorrect.
+
+Let's say that the WSDL defines this (ignoring all name-space issues)
+
+ <definitions xmlns:xx="MYNS"
+   <message name="GetLastTradePriceInput">
+    <part name="count" type="int" />
+    <part name="request" element="xx:TradePriceRequest"/>
+   </message>
+
+   <message name="GetLastTradePriceOutput">
+    <part name="answer" element="xx:TradePrice"/>
+   </message>
+
+   <binding
+    <operation
+     <input>
+      <soap:header message="GetLastTradePriceInput" part="count"
+      <soap:body message="GetLastTradePriceInput" parts="request"
+     <output>
+      <soap:body message="GetLastTradePriceOutput"
+
+The input message needs explicitly named parts in this case, where the
+output message simply uses all defined in the body.  So, the input message
+has one header part C<count>, and one body part C<request>.  The output
+message only has one part named C<answer>, which is all defined for the
+message and therefore its name can be omitted.
+
+Then, the definitions of the blocks:
+
+ <schema targetNamespace="MYNS"
+   <element name="TradePriceRequest">
+    <complexType>
+     <all>
+      <element name="tickerSymbol" type="string"/>
+
+   <element name="TradePrice">
+    <complexType>
+     <all>
+      <element name="price" type="float"/>
+ </schema>
+
+Now, calling the compiled function can be done like this:
+
+  my $got
+     = $call->(  count => 5, request => {tickerSymbol => 'IBM'}  );
+     = $call->({ count => 5, request => {tickerSymbol => 'IBM'} });
+     = $call->({ count => 5, request => {tickerSymbol => 'IBM'} }
+        , 'UTF-8');
+
+If the first arguments for the code ref is a HASH, then there may be
+a second which specifies the required character-set.  The default is
+C<UTF-8>, which is very much advised.
+
+=subsection Parameter unpacking (Document Style)
+
+In the example situation of previous section, you may simplify the
+call even further.  To understand how, we need to understand the
+parameter unpacking algorithm.
+
+The structure which we need to end up with, looks like this
+
+  $call->(\%data, $charset);
+  %data = ( Header => {count => 5}
+          , Body   =>
+             { request => {tickerSymbol => 'IBM'} }
+          );
+
+The structure of the SOAP message is directly mapped on this
+nested complex HASH.  But is inconvenient to write each call
+like this, therefore the C<$call> parameters are transformed into
+the required structure according to the following rules:
+
+=over 4
+=item 1.
+if called with a LIST, then that will become a HASH
+
+=item 2.
+when a C<Header> and/or C<Body> are found in the HASH, those are used
+
+=item 3.
+if there are more parameters in the HASH, then those with names of
+known header and headerfault message parts are moved to the C<Header>
+sub-structure.  Body and fault message parts are moved to the C<Body>
+sub-structure.
+
+=item 4.
+If the C<Body> sub-structure is empty, and there is only one body part
+expected, then all remaining parameters are put in a HASH for that part.
+This also happens if there are not parameters: it will result in an
+empty HASH for that block.
+
+=back
+
+So, in our case this will also do, because C<count> is a known part,
+and C<request> gets all left-overs, being the only body part.
+
+ my $got = $call->(count => 5, tickerSymbol => 'IBM');
+
+This does not work if the block element is a simple type.  In most
+existing Document style SOAP schemas, this simplification probably
+is possible.
+
+=subsection Understanding the output (Document style)
+
+The C<$got> is a HASH, which will not be simplified automatically:
+it may change with future extensions of the interface.  The return
+is a complex nested structure, and M<Data::Dumper> is your friend.
+
+ $got = { answer => { price => 16.3 } }
+
+To access the value use
+
+ printf "%.2f US\$\n", $got->{answer}->{price};
+ printf "%.2f US\$\n", $got->{answer}{price};   # same
+
+or
+
+ my $answer = $got->{answer};
+ printf "%.2f US\$\n", $answer->{price};
+
+=subsection Calling the server (SOAP-RPC style literal)
+
+SOAP-RPC style messages which have C<<use=literal>> cannot be used
+without a little help.  However, one extra definition per procedure
+call suffices.
+
+This a complete code example, although you need to fill in some
+specifics about your environment.  If you have a WSDL file, then it
+will be a little simpler, see M<XML::Compile::WSDL11::compileClient()>.
+
+ # You probably need these
+ use XML::Compile::SOAP11::Client;
+ use XML::Compile::Transport::SOAPHTTP;
+ use XML::Compile::Util  qw/pack_type/;
+
+ # Literal style RPC
+ my $outtype = pack_type $MYNS, 'myFunction';
+ my $intype  = pack_type $MYNS, 'myFunctionResponse';
+
+ # Encoded style RPC (see next section on these functions)
+ my $outtype = \&my_pack_params;
+ my $intype  = \&my_unpack_params;
+
+ # For all RPC calls, you need this only once (or have a WSDL):
+ my $transp  = XML::Compile::Transport::SOAPHTTP->new(...);
+ my $http    = $transp->compileClient(...);
+ my $soap    = XML::Compile::SOAP11::Client->new(...);
+ my $send    = $soap->compileMessage('SENDER',   style => $style, ...);
+ my $get     = $soap->compileMessage('RECEIVER', style => $style, ...);
+
+ # Per RPC procedure
+ my $myproc = $soap->compileClient
+   ( name   => 'MyProc'
+   , encode => $send, decode => $get, transport => $http
+   );
+
+ my $answer = $myproc->(@parameters);   # as document style
+
+Actually, the C<< @paramers >> are slightly less flexible as in document
+style SOAP.  If you use header blocks, then the called CODE reference
+will not be able to distinguish between parameters for the RPC block and
+parameters for the header blocks.
+
+  my $answer = $trade_price
+    ->( {symbol => 'IBM'}    # the RPC package implicit
+      , transaction => 5     # in the header
+      );
+
+When the number of arguments is odd, the first is indicating the RPC
+element, and the other pairs refer to header blocks.
+
+The C<$answer> structure may contain a C<Fault> entry, or a decoded
+datastructure with the results of your query.  One call using
+M<Data::Dumper> will show you more than I can explain in a few hundred
+words.
+
+=subsection Calling the server (SOAP-RPC style, encoded)
+
+SOAP-RPC is a simplification of the interface description: basically,
+the interface is not described at all, but left to good communication
+between the client and server authors.  In strongly typed languages,
+this is quite simple to enforce: the client side and server side use
+the same method prototypes.  However, in Perl we are blessed to go
+without these strongly typed prototypes.
+
+The approach of M<SOAP::Lite>, is to guess the types of the passed
+parameters.  For instance, "42" will get passed as Integer.  This
+may lead to nasty problems: a float parameter "2.0" will get passed
+as integer "2", or a string representing a house number "8" is passed
+as an number.  This may not be accepted by the SOAP server.
+
+So, using SOAP-RPC in M<XML::Compile::SOAP> will ask a little more
+effort from you: you have to state parameter types explicitly.  In
+the F<examples/namesservice/> directory, you find a detailed example.
+You have to create a CODE ref which produces the message, using
+methods defined provided by M<XML::Compile::SOAP11::Encoding>.
+
+=subsection Faults (Document and RPC style)
+
+Faults and headerfaults are a slightly different story: the type which
+is specified with them is not of the fault XML node itself, but of the
+C<detail> sub-element within the standard fault structure.
+
+When producing the data for faults, you must be aware of the fact that
+the structure is different for SOAP1.1 and SOAP1.2.  When interpreting
+faults, the same problems are present, although the implementation
+tries to help you by hiding the differences.
+
+Check whether SOAP1.1 or SOAP1.2 is used by looking for a C<faultcode>
+(SOAP1.1) or a C<Code> (SOAP1.2) field in the data:
+
+  if(my $fault = $got->{Fault})
+  {  if($fault->{faultcode}) { ... SOAP1.1 ... }
+     elsif($fault->{Code})   { ... SOAP1.2 ... }
+     else { die }
+  }
+
+In either protocol case, the following will get you at a compatible
+structure in two steps:
+
+  if(my $fault = $got->{Fault})
+  {   my $decoded = fault->{_NAME}};
+      print $got->{$decoded}->{code};
+      ...
+  }
+
+See the respective manuals M<XML::Compile::SOAP11> and
+M<XML::Compile::SOAP12> for the hairy details.  But one thing can be said:
+when the fault is declared formally, then the C<_NAME> will be the name
+of that part.
+
+=section SOAP without WSDL (Document style)
+
+See the manual page of M<XML::Compile::WSDL11> to see how simple you
+can use this module when you have a WSDL file at hand.  The creation of
+a correct WSDL file is NOT SIMPLE.
+
+When using SOAP without WSDL file, it gets a little bit more complicate
+to use: you need to describe the content of the messages yourself.
+The following example is used as test-case C<t/10soap11.t>, directly
+taken from the SOAP11 specs section 1.3 example 1.
+
+ # for simplification
+ my $TestNS   = 'http://test-types';
+ use XML::Compile::Util qw/SCHEMA2001/;
+ my $SchemaNS = SCHEMA2001;
+
+First, the schema (hopefully someone else created for you, because they
+can be quite hard to create correctly) is in file C<myschema.xsd>
+
+ <schema targetNamespace="$TestNS"
+   xmlns="$SchemaNS">
+
+ <element name="GetLastTradePrice">
+   <complexType>
+      <all>
+        <element name="symbol" type="string"/>
+      </all>
+   </complexType>
+ </element>
+
+ <element name="GetLastTradePriceResponse">
+   <complexType>
+      <all>
+         <element name="price" type="float"/>
+      </all>
+   </complexType>
+ </element>
+
+ <element name="Transaction" type="int"/>
+ </schema>
+
+Ok, now the program you create the request:
+
+ use XML::Compile::SOAP11;
+ use XML::Compile::Util  qw/pack_type/;
+
+ my $soap   = XML::Compile::SOAP11->new;
+ $soap->schemas->importDefinitions('myschema.xsd');
+
+ my $get_price = $soap->compileMessage
+   ( 'SENDER'
+   , header =>
+      [ transaction => pack_type($TestNS, 'Transaction') ]
+   , body  =>
+      [ request => pack_type($TestNS, 'GetLastTradePrice') ]
+   , mustUnderstand => 'transaction'
+   , destination    => [ transaction => 'NEXT http://actor' ]
+   );
+
+C<INPUT> is used in the WSDL terminology, indicating this message is
+an input message for the server.  This C<$get_price> is a WRITER.  Above
+is done only once in the initialization phase of your program.
+
+At run-time, you have to call the CODE reference with a
+data-structure which is compatible with the schema structure.
+(See M<XML::Compile::Schema::template()> if you have no clue how it should
+look)  So: let's send this:
+
+ # insert your data
+ my %data_in = (transaction => 5, request => {symbol => 'DIS'});
+ my %data_in = (transaction => 5, symbol => 'DIS'); # alternative
+
+ # create a XML::LibXML tree
+ my $xml  = $get_price->(\%data_in, 'UTF-8');
+ print $xml->toString;
+
+And the output is:
+
+ <SOAP-ENV:Envelope
+    xmlns:x0="http://test-types"
+    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
+   <SOAP-ENV:Header>
+     <x0:Transaction
+       mustUnderstand="1"
+       actor="http://schemas.xmlsoap.org/soap/actor/next http://actor">
+         5
+     </x0:Transaction>
+   </SOAP-ENV:Header>
+   <SOAP-ENV:Body>
+     <x0:GetLastTradePrice>
+       <symbol>DIS</symbol>
+     </x0:GetLastTradePrice>
+   </SOAP-ENV:Body>
+ </SOAP-ENV:Envelope>
+
+Some transport protocol will sent this data from the client to the
+server.  See M<XML::Compile::Transport::SOAPHTTP>, as one example.
+
+On the SOAP server side, we will parse the message.  The string C<$soap>
+contains the XML.  The program looks like this:
+
+ my $server = $soap->compileMessage # create once
+  ( 'RECEIVER'
+  , header => [ transaction => pack_type($TestNS, 'Transaction') ]
+  , body   => [ request => pack_type($TestNS, 'GetLastTradePrice') ]
+  );
+
+ my $data_out = $server->($soap);   # call often
+
+Now, the C<$data_out> reference on the server, is stucturally exactly 
+equivalent to the C<%data_in> from the client.
+
+=cut
 
 1;
diff --git a/lib/XML/Compile/SOAP/Client.pod b/lib/XML/Compile/SOAP/Client.pod
deleted file mode 100644
index 9fed2eb..0000000
--- a/lib/XML/Compile/SOAP/Client.pod
+++ /dev/null
@@ -1,502 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Client - SOAP message initiators
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP::Client is extended by
-   XML::Compile::SOAP11::Client
-   XML::Compile::SOAP12::Client
-
-=head1 SYNOPSIS
-
- # never used directly, only via XML::Compile::SOAP1[12]::Client
-
-=head1 DESCRIPTION
-
-This class defines the methods that each client side of the SOAP
-message exchange protocols must implement.
-
-=head1 METHODS
-
-=head2 Constructors
-
-This object can not be instantiated, but is only used as secundary
-base class.  The primary must contain the C<new>.
-
-=head2 Handlers
-
-=over 4
-
-=item $obj-E<gt>B<compileClient>(%options)
-
- -Option   --Default
-  async      <false>
-  decode     <required>
-  encode     <required>
-  kind       request-response
-  name       <undef>
-  soap       'SOAP11'
-  transport  <required>
-
-=over 2
-
-=item async => BOOLEAN
-
-If true, a whole different code-reference is returned. Each time it
-is called, the call will be made but the function returns immediately.
-As additional parameter to the call, you must provide a C<_callback>
-parameter which is a code-reference which will handle the result.
-
-=item decode => CODE
-
-The CODE reference is produced by L<XML::Compile::SOAP::compileMessage()|XML::Compile::SOAP/"Single message">,
-and must be a RECEIVER: translate a SOAP message into Perl data.  Even in
-one-way operation, this decode should be provided: some servers may pass
-back some XML in case of errors.
-
-=item encode => CODE
-
-The CODE reference is produced by L<XML::Compile::SOAP::compileMessage()|XML::Compile::SOAP/"Single message">,
-and must be a SENDER: translates Perl data structures into the SOAP
-message in XML.
-
-=item kind => STRING
-
-Which kind of client is this.  WSDL11 defines four kinds of client-server
-interaction.  Only C<request-response> (the default) and C<one-way> are
-currently supported.
-
-=item name => STRING
-
-=item soap => OBJECT|'SOAP11'|'SOAP12'
-
-When the transport parameter is an object, this is used to wrap the
-SOAP content according to the matching transporter regulation.
-
-=item transport => CODE|OBJECT
-
-The CODE reference is produced by an extensions of
-L<XML::Compile::Transport::compileClient()|XML::Compile::Transport/"Handlers"> (usually
-L<XML::Compile::Transport::SOAPHTTP::compileClient()|XML::Compile::Transport::SOAPHTTP/"Handlers">.
-
-If you pass a L<XML::Compile::Transport::SOAPHTTP|XML::Compile::Transport::SOAPHTTP> object, the
-compileClient will be called for you.  This is possible in case you do
-not have any configuration options to pass with the compileClient().
-
-=back
-
-example: 
-
-Normal call:
-
-   my $call = $wsdl->compileClient('myOp');
-   my ($answer, $trace) = $call->(@params);
-   #do something with $answer
-
-Async call:
-
-   my $call = $wsdl->compileClient('myOp', async => 1);
-   sub cb
-   {  my ($answer, $trace) = @_;
-      #do something with $answer
-   };
-   $call->(@params, _callback => \&cb);
-
-=back
-
-=head1 DETAILS
-
-=head2 Client side SOAP
-
-=head3 Calling the server (Document style)
-
-First, you compile the call either via a WSDL file (see
-L<XML::Compile::WSDL11|XML::Compile::WSDL11>), or in a few manual steps (which are described
-in the next section).  In either way, you end-up with a CODE references
-which can be called multiple times.
-
-    # compile once
-    my $call   = $soap->compileClient(...);
-
-    # and call often
-    my $answer = $call->(%request);  # list of pairs
-    my $answer = $call->(\%request); # same, but HASH
-    my $answer = $call->(\%request, 'UTF-8');  # same
-
-    # or with trace details, see XML::Compile::SOAP::Trace
-    my ($answer, $trace) = $call->...
-
-But what is the structure of C<%request> and C<$answer>?  Well, there
-are various syntaxes possible: from structurally perfect, to user-friendly.
-
-First, find out which data structures can be present: when you compiled
-your messages explicitly, you have picked your own names.  When the
-call was initiated from a WSDL file, then you have to find the names of
-the message parts which can be used: the part names for header blocks,
-body blocks, headerfaults, and (body) faults.  Do not worry to much,
-you will get (hopefully understandable) run-time error messages when
-the structure is incorrect.
-
-Let's say that the WSDL defines this (ignoring all name-space issues)
-
- <definitions xmlns:xx="MYNS"
-   <message name="GetLastTradePriceInput">
-    <part name="count" type="int" />
-    <part name="request" element="xx:TradePriceRequest"/>
-   </message>
-
-   <message name="GetLastTradePriceOutput">
-    <part name="answer" element="xx:TradePrice"/>
-   </message>
-
-   <binding
-    <operation
-     <input>
-      <soap:header message="GetLastTradePriceInput" part="count"
-      <soap:body message="GetLastTradePriceInput" parts="request"
-     <output>
-      <soap:body message="GetLastTradePriceOutput"
-
-The input message needs explicitly named parts in this case, where the
-output message simply uses all defined in the body.  So, the input message
-has one header part C<count>, and one body part C<request>.  The output
-message only has one part named C<answer>, which is all defined for the
-message and therefore its name can be omitted.
-
-Then, the definitions of the blocks:
-
- <schema targetNamespace="MYNS"
-   <element name="TradePriceRequest">
-    <complexType>
-     <all>
-      <element name="tickerSymbol" type="string"/>
-
-   <element name="TradePrice">
-    <complexType>
-     <all>
-      <element name="price" type="float"/>
- </schema>
-
-Now, calling the compiled function can be done like this:
-
-  my $got
-     = $call->(  count => 5, request => {tickerSymbol => 'IBM'}  );
-     = $call->({ count => 5, request => {tickerSymbol => 'IBM'} });
-     = $call->({ count => 5, request => {tickerSymbol => 'IBM'} }
-        , 'UTF-8');
-
-If the first arguments for the code ref is a HASH, then there may be
-a second which specifies the required character-set.  The default is
-C<UTF-8>, which is very much advised.
-
-=head3 Parameter unpacking (Document Style)
-
-In the example situation of previous section, you may simplify the
-call even further.  To understand how, we need to understand the
-parameter unpacking algorithm.
-
-The structure which we need to end up with, looks like this
-
-  $call->(\%data, $charset);
-  %data = ( Header => {count => 5}
-          , Body   =>
-             { request => {tickerSymbol => 'IBM'} }
-          );
-
-The structure of the SOAP message is directly mapped on this
-nested complex HASH.  But is inconvenient to write each call
-like this, therefore the C<$call> parameters are transformed into
-the required structure according to the following rules:
-
-=over 4
-
-=item 1.
-
-if called with a LIST, then that will become a HASH
-
-=item 2.
-
-when a C<Header> and/or C<Body> are found in the HASH, those are used
-
-=item 3.
-
-if there are more parameters in the HASH, then those with names of
-known header and headerfault message parts are moved to the C<Header>
-sub-structure.  Body and fault message parts are moved to the C<Body>
-sub-structure.
-
-=item 4.
-
-If the C<Body> sub-structure is empty, and there is only one body part
-expected, then all remaining parameters are put in a HASH for that part.
-This also happens if there are not parameters: it will result in an
-empty HASH for that block.
-
-=back
-
-So, in our case this will also do, because C<count> is a known part,
-and C<request> gets all left-overs, being the only body part.
-
- my $got = $call->(count => 5, tickerSymbol => 'IBM');
-
-This does not work if the block element is a simple type.  In most
-existing Document style SOAP schemas, this simplification probably
-is possible.
-
-=head3 Understanding the output (Document style)
-
-The C<$got> is a HASH, which will not be simplified automatically:
-it may change with future extensions of the interface.  The return
-is a complex nested structure, and Data::Dumper is your friend.
-
- $got = { answer => { price => 16.3 } }
-
-To access the value use
-
- printf "%.2f US\$\n", $got->{answer}->{price};
- printf "%.2f US\$\n", $got->{answer}{price};   # same
-
-or
-
- my $answer = $got->{answer};
- printf "%.2f US\$\n", $answer->{price};
-
-=head3 Calling the server (SOAP-RPC style literal)
-
-SOAP-RPC style messages which have C<<use=literal>> cannot be used
-without a little help.  However, one extra definition per procedure
-call suffices.
-
-This a complete code example, although you need to fill in some
-specifics about your environment.  If you have a WSDL file, then it
-will be a little simpler, see L<XML::Compile::WSDL11::compileClient()|XML::Compile::WSDL11/"Extension">.
-
- # You probably need these
- use XML::Compile::SOAP11::Client;
- use XML::Compile::Transport::SOAPHTTP;
- use XML::Compile::Util  qw/pack_type/;
-
- # Literal style RPC
- my $outtype = pack_type $MYNS, 'myFunction';
- my $intype  = pack_type $MYNS, 'myFunctionResponse';
-
- # Encoded style RPC (see next section on these functions)
- my $outtype = \&my_pack_params;
- my $intype  = \&my_unpack_params;
-
- # For all RPC calls, you need this only once (or have a WSDL):
- my $transp  = XML::Compile::Transport::SOAPHTTP->new(...);
- my $http    = $transp->compileClient(...);
- my $soap    = XML::Compile::SOAP11::Client->new(...);
- my $send    = $soap->compileMessage('SENDER',   style => $style, ...);
- my $get     = $soap->compileMessage('RECEIVER', style => $style, ...);
-
- # Per RPC procedure
- my $myproc = $soap->compileClient
-   ( name   => 'MyProc'
-   , encode => $send, decode => $get, transport => $http
-   );
-
- my $answer = $myproc->(@parameters);   # as document style
-
-Actually, the C<< @paramers >> are slightly less flexible as in document
-style SOAP.  If you use header blocks, then the called CODE reference
-will not be able to distinguish between parameters for the RPC block and
-parameters for the header blocks.
-
-  my $answer = $trade_price
-    ->( {symbol => 'IBM'}    # the RPC package implicit
-      , transaction => 5     # in the header
-      );
-
-When the number of arguments is odd, the first is indicating the RPC
-element, and the other pairs refer to header blocks.
-
-The C<$answer> structure may contain a C<Fault> entry, or a decoded
-datastructure with the results of your query.  One call using
-Data::Dumper will show you more than I can explain in a few hundred
-words.
-
-=head3 Calling the server (SOAP-RPC style, encoded)
-
-SOAP-RPC is a simplification of the interface description: basically,
-the interface is not described at all, but left to good communication
-between the client and server authors.  In strongly typed languages,
-this is quite simple to enforce: the client side and server side use
-the same method prototypes.  However, in Perl we are blessed to go
-without these strongly typed prototypes.
-
-The approach of SOAP::Lite, is to guess the types of the passed
-parameters.  For instance, "42" will get passed as Integer.  This
-may lead to nasty problems: a float parameter "2.0" will get passed
-as integer "2", or a string representing a house number "8" is passed
-as an number.  This may not be accepted by the SOAP server.
-
-So, using SOAP-RPC in L<XML::Compile::SOAP|XML::Compile::SOAP> will ask a little more
-effort from you: you have to state parameter types explicitly.  In
-the F<examples/namesservice/> directory, you find a detailed example.
-You have to create a CODE ref which produces the message, using
-methods defined provided by L<XML::Compile::SOAP11::Encoding|XML::Compile::SOAP11::Encoding>.
-
-=head3 Faults (Document and RPC style)
-
-Faults and headerfaults are a slightly different story: the type which
-is specified with them is not of the fault XML node itself, but of the
-C<detail> sub-element within the standard fault structure.
-
-When producing the data for faults, you must be aware of the fact that
-the structure is different for SOAP1.1 and SOAP1.2.  When interpreting
-faults, the same problems are present, although the implementation
-tries to help you by hiding the differences.
-
-Check whether SOAP1.1 or SOAP1.2 is used by looking for a C<faultcode>
-(SOAP1.1) or a C<Code> (SOAP1.2) field in the data:
-
-  if(my $fault = $got->{Fault})
-  {  if($fault->{faultcode}) { ... SOAP1.1 ... }
-     elsif($fault->{Code})   { ... SOAP1.2 ... }
-     else { die }
-  }
-
-In either protocol case, the following will get you at a compatible
-structure in two steps:
-
-  if(my $fault = $got->{Fault})
-  {   my $decoded = fault->{_NAME}};
-      print $got->{$decoded}->{code};
-      ...
-  }
-
-See the respective manuals L<XML::Compile::SOAP11|XML::Compile::SOAP11> and
-L<XML::Compile::SOAP12|XML::Compile::SOAP12> for the hairy details.  But one thing can be said:
-when the fault is declared formally, then the C<_NAME> will be the name
-of that part.
-
-=head2 SOAP without WSDL (Document style)
-
-See the manual page of L<XML::Compile::WSDL11|XML::Compile::WSDL11> to see how simple you
-can use this module when you have a WSDL file at hand.  The creation of
-a correct WSDL file is NOT SIMPLE.
-
-When using SOAP without WSDL file, it gets a little bit more complicate
-to use: you need to describe the content of the messages yourself.
-The following example is used as test-case C<t/10soap11.t>, directly
-taken from the SOAP11 specs section 1.3 example 1.
-
- # for simplification
- my $TestNS   = 'http://test-types';
- use XML::Compile::Util qw/SCHEMA2001/;
- my $SchemaNS = SCHEMA2001;
-
-First, the schema (hopefully someone else created for you, because they
-can be quite hard to create correctly) is in file C<myschema.xsd>
-
- <schema targetNamespace="$TestNS"
-   xmlns="$SchemaNS">
-
- <element name="GetLastTradePrice">
-   <complexType>
-      <all>
-        <element name="symbol" type="string"/>
-      </all>
-   </complexType>
- </element>
-
- <element name="GetLastTradePriceResponse">
-   <complexType>
-      <all>
-         <element name="price" type="float"/>
-      </all>
-   </complexType>
- </element>
-
- <element name="Transaction" type="int"/>
- </schema>
-
-Ok, now the program you create the request:
-
- use XML::Compile::SOAP11;
- use XML::Compile::Util  qw/pack_type/;
-
- my $soap   = XML::Compile::SOAP11->new;
- $soap->schemas->importDefinitions('myschema.xsd');
-
- my $get_price = $soap->compileMessage
-   ( 'SENDER'
-   , header =>
-      [ transaction => pack_type($TestNS, 'Transaction') ]
-   , body  =>
-      [ request => pack_type($TestNS, 'GetLastTradePrice') ]
-   , mustUnderstand => 'transaction'
-   , destination    => [ transaction => 'NEXT http://actor' ]
-   );
-
-C<INPUT> is used in the WSDL terminology, indicating this message is
-an input message for the server.  This C<$get_price> is a WRITER.  Above
-is done only once in the initialization phase of your program.
-
-At run-time, you have to call the CODE reference with a
-data-structure which is compatible with the schema structure.
-(See L<XML::Compile::Schema::template()|XML::Compile::Schema/"Compilers"> if you have no clue how it should
-look)  So: let's send this:
-
- # insert your data
- my %data_in = (transaction => 5, request => {symbol => 'DIS'});
- my %data_in = (transaction => 5, symbol => 'DIS'); # alternative
-
- # create a XML::LibXML tree
- my $xml  = $get_price->(\%data_in, 'UTF-8');
- print $xml->toString;
-
-And the output is:
-
- <SOAP-ENV:Envelope
-    xmlns:x0="http://test-types"
-    xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
-   <SOAP-ENV:Header>
-     <x0:Transaction
-       mustUnderstand="1"
-       actor="http://schemas.xmlsoap.org/soap/actor/next http://actor">
-         5
-     </x0:Transaction>
-   </SOAP-ENV:Header>
-   <SOAP-ENV:Body>
-     <x0:GetLastTradePrice>
-       <symbol>DIS</symbol>
-     </x0:GetLastTradePrice>
-   </SOAP-ENV:Body>
- </SOAP-ENV:Envelope>
-
-Some transport protocol will sent this data from the client to the
-server.  See L<XML::Compile::Transport::SOAPHTTP|XML::Compile::Transport::SOAPHTTP>, as one example.
-
-On the SOAP server side, we will parse the message.  The string C<$soap>
-contains the XML.  The program looks like this:
-
- my $server = $soap->compileMessage # create once
-  ( 'RECEIVER'
-  , header => [ transaction => pack_type($TestNS, 'Transaction') ]
-  , body   => [ request => pack_type($TestNS, 'GetLastTradePrice') ]
-  );
-
- my $data_out = $server->($soap);   # call often
-
-Now, the C<$data_out> reference on the server, is stucturally exactly 
-equivalent to the C<%data_in> from the client.
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Extension.pm b/lib/XML/Compile/SOAP/Extension.pm
index 13f09b2..da4dd06 100644
--- a/lib/XML/Compile/SOAP/Extension.pm
+++ b/lib/XML/Compile/SOAP/Extension.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Extension;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -18,6 +11,25 @@ use Log::Report 'xml-compile-soap';
 
 my @ext;
 
+=chapter NAME
+XML::Compile::SOAP::Extension - plugins for standards
+
+=chapter SYNOPSIS
+ # only as base-class
+
+=chapter DESCRIPTION
+This module defines hooks which are used to implement the SOAP and
+WSDL extensions. Hooks are created on critial spots, where additional
+standards play tricks with the logic of SOAP and WSDL. There are a
+lot of those standards, for instance Web Service Addressing (WSA,
+M<XML::Compile::SOAP::WSA>)
+
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+=cut
 
 sub new($@) { my $class = shift; (bless {}, $class)->init( {@_} ) }
 
@@ -29,6 +41,12 @@ sub init($)
 }
 
 #--------
+=section WSDL11
+
+=ci_method wsdl11Init $wsdl, $args
+Do not use this hook for adding WSDLs or schemas, unless those are
+used to interpret $wsdl or SOAP files correctly.
+=cut
 
 ### For all methods named below: when called on an object, it is the stub
 ### for the extension. Only when called as class method, it will walk all
@@ -40,12 +58,19 @@ sub wsdl11Init($$)
 }
 
 #--------
+=section SOAP11
+
+=ci_method soap11OperationInit $operation, $args
+$args is a reference.
+=cut
 
 sub soap11OperationInit($$)
 {   ref shift and return;
     $_->soap11OperationInit(@_) for @ext;
 }
 
+=method soap11ClientWrapper $operation, $call, $args
+=cut
 
 sub soap11ClientWrapper($$$)
 {   ref shift and return $_[1];
@@ -54,6 +79,10 @@ sub soap11ClientWrapper($$$)
     $call;
 }
 
+=method soap11HandlerWrapper $operation, $callback, $args
+Called before the handler is created, to influence the encoder and
+decoder. Returned is a wrapped callback, or the same.
+=cut
 
 sub soap11HandlerWrapper($$$)
 {   my ($thing, $op, $cb, $args) = @_;
@@ -63,12 +92,19 @@ sub soap11HandlerWrapper($$$)
 }
 
 #--------
+=section SOAP12
+
+=ci_method soap12OperationInit $operation, $args
+$args is a reference.
+=cut
 
 sub soap12OperationInit($$)
 {   ref shift and return;
     $_->soap12OperationInit(@_) for @ext;
 }
 
+=method soap12ClientWrapper $operation, $call, $args
+=cut
 
 sub soap12ClientWrapper($$$)
 {   ref shift and return $_[1];
@@ -77,6 +113,10 @@ sub soap12ClientWrapper($$$)
     $call;
 }
 
+=method soap12HandlerWrapper $operation, $callback, $args
+Called before the handler is created, to influence the encoder and
+decoder. Returned is a wrapped callback, or the same.
+=cut
 
 sub soap12HandlerWrapper($$$)
 {   my ($thing, $op, $cb, $args) = @_;
diff --git a/lib/XML/Compile/SOAP/Extension.pod b/lib/XML/Compile/SOAP/Extension.pod
deleted file mode 100644
index b09d3b6..0000000
--- a/lib/XML/Compile/SOAP/Extension.pod
+++ /dev/null
@@ -1,98 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Extension - plugins for standards
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP::Extension is extended by
-   XML::Compile::SOAP::WSA
-   XML::Compile::Transport
-
-=head1 SYNOPSIS
-
- # only as base-class
-
-=head1 DESCRIPTION
-
-This module defines hooks which are used to implement the SOAP and
-WSDL extensions. Hooks are created on critial spots, where additional
-standards play tricks with the logic of SOAP and WSDL. There are a
-lot of those standards, for instance Web Service Addressing (WSA,
-L<XML::Compile::SOAP::WSA|XML::Compile::SOAP::WSA>)
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item XML::Compile::SOAP::Extension-E<gt>B<new>(%options)
-
-=back
-
-=head2 WSDL11
-
-=over 4
-
-=item $obj-E<gt>B<wsdl11Init>($wsdl, $args)
-
-=item XML::Compile::SOAP::Extension-E<gt>B<wsdl11Init>($wsdl, $args)
-
-Do not use this hook for adding WSDLs or schemas, unless those are
-used to interpret $wsdl or SOAP files correctly.
-
-=back
-
-=head2 SOAP11
-
-=over 4
-
-=item $obj-E<gt>B<soap11ClientWrapper>($operation, $call, $args)
-
-=item $obj-E<gt>B<soap11HandlerWrapper>($operation, $callback, $args)
-
-Called before the handler is created, to influence the encoder and
-decoder. Returned is a wrapped callback, or the same.
-
-=item $obj-E<gt>B<soap11OperationInit>($operation, $args)
-
-=item XML::Compile::SOAP::Extension-E<gt>B<soap11OperationInit>($operation, $args)
-
-$args is a reference.
-
-=back
-
-=head2 SOAP12
-
-=over 4
-
-=item $obj-E<gt>B<soap12ClientWrapper>($operation, $call, $args)
-
-=item $obj-E<gt>B<soap12HandlerWrapper>($operation, $callback, $args)
-
-Called before the handler is created, to influence the encoder and
-decoder. Returned is a wrapped callback, or the same.
-
-=item $obj-E<gt>B<soap12OperationInit>($operation, $args)
-
-=item XML::Compile::SOAP::Extension-E<gt>B<soap12OperationInit>($operation, $args)
-
-$args is a reference.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/FAQ.pod b/lib/XML/Compile/SOAP/FAQ.pod
index 39e5600..a3105fc 100644
--- a/lib/XML/Compile/SOAP/FAQ.pod
+++ b/lib/XML/Compile/SOAP/FAQ.pod
@@ -1,5 +1,3 @@
-=encoding utf8
-
 =head1 NAME
 
 XML::Compile::SOAP::FAQ - frequently asked questions
@@ -11,7 +9,7 @@ the XML::Compile::SOAP modules.  Or better said: let's hope there will
 be more in the future. If you have contributions either in question or
 as answer, then please contribute via the xml mailinglist.
 
-Also read L<XML::Compile::FAQ|XML::Compile::FAQ>.
+Also read M<XML::Compile::FAQ>.
 
 =head2 Modifing the messages
 
@@ -19,7 +17,7 @@ Also read L<XML::Compile::FAQ|XML::Compile::FAQ>.
 
 Although WSDLs offer a nice way to define header-fields explicitly, quite
 a number of applications require fields which are not described. Also
-some W3C standards play this game.  See L<XML::Compile::SOAP::WSA|XML::Compile::SOAP::WSA>
+some W3C standards play this game.  See M<XML::Compile::SOAP::WSA>
 for a complex example. A simple example follows here.
 
   use warnings;
@@ -145,13 +143,14 @@ authentication.  You need something like this:
    my $call = $wsdl->compileClient($operation, user_agent => $ua
     , transport_hook => \&basic_auth);
 
+
    sub basic_auth($$)
    {   my ($request, $trace) = @_;
        $request->authorization_basic($user, $password);
        $ua->request($request);     # returns $response
    }
 
-That's all.  When you use L<XML::Compile::Cache|XML::Compile::Cache> to maintain the
+That's all.  When you use M<XML::Compile::Cache> to maintain the
 calls (advised), it would look like this:
 
    $wsdl->compileCalls(user_agent => $ua, transport_hook => \&basic_auth);
@@ -178,7 +177,7 @@ In your program, you typically start with
   my $wsdl = XML::Compile::WSDL11->new($wsdl_filename);
   $wsdl->importDefinitions([glob "*.xsd"]);
 
-=head2 Using SSL
+=head2 Using SSL / https end-points
 
 Abeltje contributed an SSL usage example, which then got adapted to this:
 
@@ -195,16 +194,3 @@ Abeltje contributed an SSL usage example, which then got adapted to this:
 
 Do not forget to explicitly install C<LWP::Protocol::https> !!!
 
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Operation.pm b/lib/XML/Compile/SOAP/Operation.pm
index 4fea383..8c3eb9b 100644
--- a/lib/XML/Compile/SOAP/Operation.pm
+++ b/lib/XML/Compile/SOAP/Operation.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Operation;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -31,6 +24,57 @@ my %servers =
     # more in XML::Compile::Licensed
   );
 
+=chapter NAME
+
+XML::Compile::SOAP::Operation - base-class for possible interactions
+
+=chapter SYNOPSIS
+ # created by XML::Compile::WSDL11
+ my $op = $wsdl->operation('GetStockPrices');
+
+=chapter DESCRIPTION
+These objects are created by M<XML::Compile::WSDL11>, grouping information
+about a certain specific message interchange between a client and
+a server.
+
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+=requires name STRING
+
+=requires kind 'one-way'|...
+This returns the type of operation this is.  There are four kinds, which
+are returned as strings C<one-way>, C<request-response>, C<sollicit-response>,
+and C<notification>.  The latter two are initiated by a server, the former
+two by a client.
+
+=option   transport URI|'HTTP'
+=default  transport 'HTTP'
+C<HTTP> is short for C<http://schemas.xmlsoap.org/soap/http/>, which
+is a constant to indicate that transport should use the HyperText
+Transfer Protocol.
+
+=option   endpoints ADDRESS|ARRAY
+=default  endpoints []
+Where to contact the server.
+
+=option   action STRING
+=default  action undef
+Some string which is referring to the action which is taken.  For SOAP
+protocols, this defines the soapAction header.
+
+=requires schemas XML::Compile::Cache
+
+=option  server_type NAME
+=default server_type C<undef>
+Most server implementations show some problems.  Also, servers may produce
+responses using their own namespaces (like for error codes).  When you know
+which server you are talking to, the quirks of the specific server type can
+be loaded.  Read more in the L<XML::Compile::SOAP/"Supported servers">.
+
+=cut
 
 sub new(@) { my $class = shift; (bless {}, $class)->init( {@_} ) }
 
@@ -91,6 +135,15 @@ sub _server_type($)
 }
 
 #----------------
+=section Accessors
+=method kind 
+=method name 
+=method schemas 
+=method version 
+=method serviceName 
+=method bindingName 
+=method portName 
+=cut
 
 sub schemas()   {shift->{schemas}}
 sub kind()      {shift->{kind}}
@@ -104,19 +157,43 @@ sub serviceName() {shift->{servname}}
 sub portName()    {shift->{portname}}
 sub portTypeName(){shift->{porttypename}}
 
+=method soapAction 
+Used for the C<soapAction> header in HTTP transport, for routing
+messages through firewalls.
+=cut
 
 sub soapAction  {shift->{action}}
 sub action()    {shift->{action}} # deprecated
 
+=method wsaAction 'INPUT'|'OUTPUT'
+Only available when C<XML::Compile::SOAP::WSA> is loaded. It specifies
+the name of the operation in the WSA header.  With C<INPUT>, it is the
+Action to be used with a message sent to the server (input to the
+server). The C<OUTPUT> is used by the server in its message back.
+=cut
 # wsaAction is implement in XML::Compile::SOAP::WSA
 
+=method serverClass 
+Returns the class name which implements the Server side for this protocol.
+
+=method clientClass 
+Returns the class name which implements the Client side for this protocol.
+=cut
 
 sub serverClass {panic}
 sub clientClass {panic}
 
+=method endPoints 
+Returns the list of alternative URLs for the end-point, which should
+be defined within the service's port declaration.
+=cut
 
 sub endPoints() { @{shift->{endpoints}} }
 
+=method longName
+[3.06] prefix the service name before the operation name, to make it
+really unique.  A C<#> is used as separator.
+=cut
 
 sub longName()
 {   my $self = shift;
@@ -125,6 +202,40 @@ sub longName()
 
 #-------------------------------------------
 
+=section Handlers
+
+=method compileTransporter %options
+
+Create the transporter code for a certain specific target.
+
+=option  transporter CODE|XML::Compile::Transport-object
+=default transporter <created>
+The routine which will be used to exchange the data with the server.
+This code is created by an M<XML::Compile::Transport::compileClient()>
+extension.
+
+By default, a transporter compatible to the protocol is created.  However,
+in most cases you want to reuse one (HTTP1.1) connection to a server.
+
+[3.14] You may provide a M<XML::Compile::Transport> object as well.  Its
+compileClient() will be called for you.
+
+=option  transport_hook CODE
+=default transport_hook C<undef>
+Passed to M<XML::Compile::Transport::compileClient(hook)>.  Can be
+used to create off-line tests and last resort work-arounds.  See the
+DETAILs chapter in the M<XML::Compile::Transport> manual page.
+
+=option  endpoint URI|ARRAY-of-URI
+=default endpoint <from WSDL>
+Overrule the destination address(es).
+
+=option  server URI-HOST
+=default server undef
+Overrule only the server part in the endpoint, not the whole endpoint.
+This could be a string like C<username:password@myhost:4711>.  Only
+used when no explicit C<endpoint> is provided.
+=cut
 
 sub compileTransporter(@)
 {   my ($self, %args) = @_;
@@ -166,17 +277,58 @@ sub compileTransporter(@)
       );
 }
 
+=method compileClient %options
+Returns one CODE reference which handles the conversion from a perl
+data-structure into a request message, the transmission of the
+request, the receipt of the answer, and the decoding of that answer
+into a Perl data-structure.
+
+=method compileHandler %options
+Returns a code reference which translates in incoming XML message
+into Perl a data-structure, then calls the callback.  The result of
+the callback is encoded from Perl into XML and returned.
+
+=requires callback CODE
+=cut
 
 sub compileClient(@)  { panic "not implemented" }
 sub compileHandler(@) { panic "not implemented" }
 
 #---------------
+=section Helpers
+
+=method explain $wsdl, $format, $direction, %options
+Dump an annotated structure showing how the operation works, helping
+developers to understand the schema. $format is C<PERL> or C<XML>.
+
+The $direction is C<INPUT>, it will return the message which the client
+sends to the server (input for the server). The C<OUTPUT> message is
+sent as response by the server.
+=cut
 
 sub explain($$$@)
 {   my ($self, $wsdl, $format, $dir, %args) = @_;
     panic "not implemented for ".ref $self;
 }
 
+=method parsedWSDL %options
+[2.29] For some purposes, it is useful to get access to the parsed WSDL
+structure.
+
+B<Be aware> that the structure returned is consided "internal"
+and strongly influenced by behavior of M<XML::Compile>; backwards
+compatibility will not be maintained at all cost.
+
+You can use M<XML::Compile::Schema::template()> format C<TREE> to get
+more details about the element types mentioned in this structure.
+
+=example
+  use Data::Dumper;
+  $Data::Dumper::Indent    = 1;
+  $Data::Dumper::Quotekeys = 0;
+
+  print Dumper $op->parsedWSDL;
+=cut
 
 sub parsedWSDL(%)
 {   my $self = shift;
diff --git a/lib/XML/Compile/SOAP/Operation.pod b/lib/XML/Compile/SOAP/Operation.pod
deleted file mode 100644
index c695712..0000000
--- a/lib/XML/Compile/SOAP/Operation.pod
+++ /dev/null
@@ -1,247 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Operation - base-class for possible interactions
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP::Operation is extended by
-   XML::Compile::SOAP11::Operation
-   XML::Compile::SOAP12::Operation
-
-=head1 SYNOPSIS
-
- # created by XML::Compile::WSDL11
- my $op = $wsdl->operation('GetStockPrices');
-
-=head1 DESCRIPTION
-
-These objects are created by L<XML::Compile::WSDL11|XML::Compile::WSDL11>, grouping information
-about a certain specific message interchange between a client and
-a server.
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item XML::Compile::SOAP::Operation-E<gt>B<new>(%options)
-
- -Option     --Default
-  action       undef
-  endpoints    []
-  kind         <required>
-  name         <required>
-  schemas      <required>
-  server_type  undef
-  transport    'HTTP'
-
-=over 2
-
-=item action => STRING
-
-Some string which is referring to the action which is taken.  For SOAP
-protocols, this defines the soapAction header.
-
-=item endpoints => ADDRESS|ARRAY
-
-Where to contact the server.
-
-=item kind => 'one-way'|...
-
-This returns the type of operation this is.  There are four kinds, which
-are returned as strings C<one-way>, C<request-response>, C<sollicit-response>,
-and C<notification>.  The latter two are initiated by a server, the former
-two by a client.
-
-=item name => STRING
-
-=item schemas => XML::Compile::Cache
-
-=item server_type => NAME
-
-Most server implementations show some problems.  Also, servers may produce
-responses using their own namespaces (like for error codes).  When you know
-which server you are talking to, the quirks of the specific server type can
-be loaded.  Read more in the L<XML::Compile::SOAP/"Supported servers">.
-
-=item transport => URI|'HTTP'
-
-C<HTTP> is short for C<http://schemas.xmlsoap.org/soap/http/>, which
-is a constant to indicate that transport should use the HyperText
-Transfer Protocol.
-
-=back
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<bindingName>()
-
-=item $obj-E<gt>B<clientClass>()
-
-Returns the class name which implements the Client side for this protocol.
-
-=item $obj-E<gt>B<endPoints>()
-
-Returns the list of alternative URLs for the end-point, which should
-be defined within the service's port declaration.
-
-=item $obj-E<gt>B<kind>()
-
-=item $obj-E<gt>B<longName>()
-
-[3.06] prefix the service name before the operation name, to make it
-really unique.  A C<#> is used as separator.
-
-=item $obj-E<gt>B<name>()
-
-=item $obj-E<gt>B<portName>()
-
-=item $obj-E<gt>B<schemas>()
-
-=item $obj-E<gt>B<serverClass>()
-
-Returns the class name which implements the Server side for this protocol.
-
-=item $obj-E<gt>B<serviceName>()
-
-=item $obj-E<gt>B<soapAction>()
-
-Used for the C<soapAction> header in HTTP transport, for routing
-messages through firewalls.
-
-=item $obj-E<gt>B<version>()
-
-=item $obj-E<gt>B<wsaAction>('INPUT'|'OUTPUT')
-
-Only available when C<XML::Compile::SOAP::WSA> is loaded. It specifies
-the name of the operation in the WSA header.  With C<INPUT>, it is the
-Action to be used with a message sent to the server (input to the
-server). The C<OUTPUT> is used by the server in its message back.
-
-=back
-
-=head2 Handlers
-
-=over 4
-
-=item $obj-E<gt>B<compileClient>(%options)
-
-Returns one CODE reference which handles the conversion from a perl
-data-structure into a request message, the transmission of the
-request, the receipt of the answer, and the decoding of that answer
-into a Perl data-structure.
-
-=item $obj-E<gt>B<compileHandler>(%options)
-
-Returns a code reference which translates in incoming XML message
-into Perl a data-structure, then calls the callback.  The result of
-the callback is encoded from Perl into XML and returned.
-
- -Option  --Default
-  callback  <required>
-
-=over 2
-
-=item callback => CODE
-
-=back
-
-=item $obj-E<gt>B<compileTransporter>(%options)
-
-Create the transporter code for a certain specific target.
-
- -Option        --Default
-  endpoint        <from WSDL>
-  server          undef
-  transport_hook  undef
-  transporter     <created>
-
-=over 2
-
-=item endpoint => URI|ARRAY-of-URI
-
-Overrule the destination address(es).
-
-=item server => URI-HOST
-
-Overrule only the server part in the endpoint, not the whole endpoint.
-This could be a string like C<username:password@myhost:4711>.  Only
-used when no explicit C<endpoint> is provided.
-
-=item transport_hook => CODE
-
-Passed to L<XML::Compile::Transport::compileClient(hook)|XML::Compile::Transport/"Handlers">.  Can be
-used to create off-line tests and last resort work-arounds.  See the
-DETAILs chapter in the L<XML::Compile::Transport|XML::Compile::Transport> manual page.
-
-=item transporter => CODE|XML::Compile::Transport-object
-
-The routine which will be used to exchange the data with the server.
-This code is created by an L<XML::Compile::Transport::compileClient()|XML::Compile::Transport/"Handlers">
-extension.
-
-By default, a transporter compatible to the protocol is created.  However,
-in most cases you want to reuse one (HTTP1.1) connection to a server.
-
-[3.14] You may provide a L<XML::Compile::Transport|XML::Compile::Transport> object as well.  Its
-compileClient() will be called for you.
-
-=back
-
-=back
-
-=head2 Helpers
-
-=over 4
-
-=item $obj-E<gt>B<explain>($wsdl, $format, $direction, %options)
-
-Dump an annotated structure showing how the operation works, helping
-developers to understand the schema. $format is C<PERL> or C<XML>.
-
-The $direction is C<INPUT>, it will return the message which the client
-sends to the server (input for the server). The C<OUTPUT> message is
-sent as response by the server.
-
-=item $obj-E<gt>B<parsedWSDL>(%options)
-
-[2.29] For some purposes, it is useful to get access to the parsed WSDL
-structure.
-
-B<Be aware> that the structure returned is consided "internal"
-and strongly influenced by behavior of L<XML::Compile|XML::Compile>; backwards
-compatibility will not be maintained at all cost.
-
-You can use L<XML::Compile::Schema::template()|XML::Compile::Schema/"Compilers"> format C<TREE> to get
-more details about the element types mentioned in this structure.
-
-example: 
-
-  use Data::Dumper;
-  $Data::Dumper::Indent    = 1;
-  $Data::Dumper::Quotekeys = 0;
-
-  print Dumper $op->parsedWSDL;
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Server.pm b/lib/XML/Compile/SOAP/Server.pm
index 1d91a1f..0f161a8 100644
--- a/lib/XML/Compile/SOAP/Server.pm
+++ b/lib/XML/Compile/SOAP/Server.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Server;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -21,6 +14,47 @@ use XML::Compile::SOAP::Util qw/:soap11/;
 use HTTP::Status qw/RC_OK RC_BAD_REQUEST RC_NOT_ACCEPTABLE
    RC_INTERNAL_SERVER_ERROR/;
 
+=chapter NAME
+XML::Compile::SOAP::Server - server-side SOAP message processing
+
+=chapter SYNOPSIS
+  # used by distribution XML::Compile::SOAP::Daemon
+
+  my $soap   = XML::Compile::SOAP11::Server->new;
+  my $input  = $soap->compileMessage('RECEIVER', ...);
+  my $output = $soap->compileMessage('SENDER', ...);
+
+  $soap->compileHandler
+    ( name => $name, input => $input, output => $output
+    , callback => \$my_handler
+    );
+
+  my $daemon = XML::Compile::SOAP::HTTPDaemon->new(...);
+  $daemon->addHandler($type => $daemon);
+
+=chapter DESCRIPTION
+This class defines methods that each server for the SOAP
+message exchange protocols must implement.
+
+=chapter METHODS
+
+=section Instantiation
+This object can not be instantiated, but is only used as secundary
+base class.  The primary must contain the C<new>.
+
+=c_method new %options
+
+=option  role URI
+=default role 'NEXT'
+In SOAP1.1, the term is 'actor', but SOAP1.2 has renamed this into
+'role': the role [this daemon] plays in the transport protocol.
+
+Please use the role abbreviations as provided by the protocol
+implementations when possible: they will be translated into the
+right URI on time.  See M<XML::Compile::SOAP::roleAbbreviation()>
+and the constants defined in M<XML::Compile::SOAP::Util>
+
+=cut
 
 sub new(@) { panic __PACKAGE__." only secundary in multiple inheritance" }
 
@@ -32,11 +66,61 @@ sub init($)
 
 #---------------------------------
 
+=section Accessors
+
+=method role 
+Returns the URI of the role (actor) of this server.
+=cut
 
 sub role() {shift->{role}}
 
 #---------------------------------
 
+=section Actions
+
+=method compileHandler %options
+Returns an HTTP status code and an M<XML::LibXML::Document> pair.
+
+=requires name STRING
+The identification for this action, for instance used for logging.  When
+the action is created via a WSDL, the portname will be used here.
+
+It is a pity that the portname is not passed in the SOAP message,
+because it is not so easy to detect which handler must be called.
+
+=option  decode CODE
+=default decode <undef>
+The CODE reference is used to decode the (parsed) XML input message
+into the pure Perl request.  The reference is a READER, created with
+M<XML::Compile::Schema::compile()>.  If no input decoder is specified,
+then the callback handler will be called with the un-decoded
+M<XML::LibXML::Document> node.
+
+=option  encode CODE
+=default encode <undef>
+The CODE reference is used to encode the Perl answer structure into the
+output message.  The reference is a WRITER.  created with
+M<XML::Compile::Schema::compile()>.  If no output encoder is specified,
+then the callback must return an M<XML::LibXML::Document>, or only
+produce error messages.
+
+=option  callback CODE
+=default callback <fault: not implemented>
+As input, the SERVER object and the translated input message (Perl version)
+are passed in.  As output, a suitable output structure must be produced.
+If the callback is not set, then a fault message will be returned to the
+user.
+
+=option  selector CODE
+=default selector sub {0}
+One way or the other, you have to figure-out whether a message addresses
+a certain process. The callback will only be used if the CODE reference
+specified here returns a true value.
+
+The CODE reference will be called with the XML version of the message,
+and a HASH which contains the information about the XML collected with
+M<XML::Compile::SOAP::messageStructure()> plus the C<soap_version> entry.
+=cut
 
 sub compileHandler(@)
 {   my ($self, %args) = @_;
@@ -99,6 +183,24 @@ sub compileHandler(@)
     };
 }
 
+=method compileFilter %options
+This routine returns a CODE reference which can be used for
+M<compileHandler(selector)>; so see whether a certain message has arrived.
+On the moment, only the first C<body> element is used to determine that.
+
+=option  body ARRAY-of-TYPES
+=default body []
+
+=option  header ARRAY-of-TYPES
+=default header <undef>
+
+=option  fault ARRAY-of-TYPES
+=default fault <undef>
+
+=option  style 'rpc'|'document'
+=default style 'document'
+
+=cut
 
 sub compileFilter(@)
 {   my ($self, %args) = @_;
@@ -132,6 +234,9 @@ sub compileFilter(@)
     };
 }
 
+=c_method faultWriter 
+Returns a CODE reference which can be used to produce faults.
+=cut
 
 sub faultWriter()
 {   my $thing = shift;
diff --git a/lib/XML/Compile/SOAP/Server.pod b/lib/XML/Compile/SOAP/Server.pod
deleted file mode 100644
index 5b13962..0000000
--- a/lib/XML/Compile/SOAP/Server.pod
+++ /dev/null
@@ -1,176 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Server - server-side SOAP message processing
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP::Server is extended by
-   XML::Compile::SOAP11::Server
-   XML::Compile::SOAP12::Server
-
-=head1 SYNOPSIS
-
-  # used by distribution XML::Compile::SOAP::Daemon
-
-  my $soap   = XML::Compile::SOAP11::Server->new;
-  my $input  = $soap->compileMessage('RECEIVER', ...);
-  my $output = $soap->compileMessage('SENDER', ...);
-
-  $soap->compileHandler
-    ( name => $name, input => $input, output => $output
-    , callback => \$my_handler
-    );
-
-  my $daemon = XML::Compile::SOAP::HTTPDaemon->new(...);
-  $daemon->addHandler($type => $daemon);
-
-=head1 DESCRIPTION
-
-This class defines methods that each server for the SOAP
-message exchange protocols must implement.
-
-=head1 METHODS
-
-=head2 Instantiation
-
-This object can not be instantiated, but is only used as secundary
-base class.  The primary must contain the C<new>.
-
-=over 4
-
-=item XML::Compile::SOAP::Server-E<gt>B<new>(%options)
-
- -Option--Default
-  role    'NEXT'
-
-=over 2
-
-=item role => URI
-
-In SOAP1.1, the term is 'actor', but SOAP1.2 has renamed this into
-'role': the role [this daemon] plays in the transport protocol.
-
-Please use the role abbreviations as provided by the protocol
-implementations when possible: they will be translated into the
-right URI on time.  See L<XML::Compile::SOAP::roleAbbreviation()|XML::Compile::SOAP/"Transcoding">
-and the constants defined in L<XML::Compile::SOAP::Util|XML::Compile::SOAP::Util>
-
-=back
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<role>()
-
-Returns the URI of the role (actor) of this server.
-
-=back
-
-=head2 Actions
-
-=over 4
-
-=item $obj-E<gt>B<compileFilter>(%options)
-
-This routine returns a CODE reference which can be used for
-L<compileHandler(selector)|XML::Compile::SOAP::Server/"Actions">; so see whether a certain message has arrived.
-On the moment, only the first C<body> element is used to determine that.
-
- -Option--Default
-  body    []
-  fault   <undef>
-  header  <undef>
-  style   'document'
-
-=over 2
-
-=item body => ARRAY-of-TYPES
-
-=item fault => ARRAY-of-TYPES
-
-=item header => ARRAY-of-TYPES
-
-=item style => 'rpc'|'document'
-
-=back
-
-=item $obj-E<gt>B<compileHandler>(%options)
-
-Returns an HTTP status code and an XML::LibXML::Document pair.
-
- -Option  --Default
-  callback  <fault: not implemented>
-  decode    <undef>
-  encode    <undef>
-  name      <required>
-  selector  sub {0}
-
-=over 2
-
-=item callback => CODE
-
-As input, the SERVER object and the translated input message (Perl version)
-are passed in.  As output, a suitable output structure must be produced.
-If the callback is not set, then a fault message will be returned to the
-user.
-
-=item decode => CODE
-
-The CODE reference is used to decode the (parsed) XML input message
-into the pure Perl request.  The reference is a READER, created with
-L<XML::Compile::Schema::compile()|XML::Compile::Schema/"Compilers">.  If no input decoder is specified,
-then the callback handler will be called with the un-decoded
-XML::LibXML::Document node.
-
-=item encode => CODE
-
-The CODE reference is used to encode the Perl answer structure into the
-output message.  The reference is a WRITER.  created with
-L<XML::Compile::Schema::compile()|XML::Compile::Schema/"Compilers">.  If no output encoder is specified,
-then the callback must return an XML::LibXML::Document, or only
-produce error messages.
-
-=item name => STRING
-
-The identification for this action, for instance used for logging.  When
-the action is created via a WSDL, the portname will be used here.
-
-It is a pity that the portname is not passed in the SOAP message,
-because it is not so easy to detect which handler must be called.
-
-=item selector => CODE
-
-One way or the other, you have to figure-out whether a message addresses
-a certain process. The callback will only be used if the CODE reference
-specified here returns a true value.
-
-The CODE reference will be called with the XML version of the message,
-and a HASH which contains the information about the XML collected with
-L<XML::Compile::SOAP::messageStructure()|XML::Compile::SOAP/"Single message"> plus the C<soap_version> entry.
-
-=back
-
-=item XML::Compile::SOAP::Server-E<gt>B<faultWriter>()
-
-Returns a CODE reference which can be used to produce faults.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Trace.pm b/lib/XML/Compile/SOAP/Trace.pm
index 9b0a764..5ea36ed 100644
--- a/lib/XML/Compile/SOAP/Trace.pm
+++ b/lib/XML/Compile/SOAP/Trace.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Trace;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -21,18 +14,66 @@ use IO::Handle;
 
 my @xml_parse_opts = (load_ext_dtd => 0, recover => 1, no_network => 1);
 
+=chapter NAME
+XML::Compile::SOAP::Trace - help displaying trace details.
+
+=chapter SYNOPSIS
+ my ($answer, $trace) = $call->(%params);
+ # now $trace is a XML::Compile::SOAP::Trace
+
+ my $req = $trace->request;   # HTTP message which was sent
+ my $res = $trace->response;  # HTTP message received
+
+ my $start = $trace->date;
+ my $dura  = $trace->elapse;
+
+ $trace->printTimings;
+ $trace->printErrors;
+ $trace->printTimings(\*STDERR);
+ $trace->printRequest(pretty_print => 1);
+ $trace->printResponse;
+
+=chapter DESCRIPTION
+This help module simplifies user access to the trace data,
+as produced by a SOAP call (client side).
+
+=chapter METHODS
+
+=section Constructors
+=c_method new %options
+Called by the SOAP call implementation; not for normal users.
+=cut
 
 sub new($)
 {   my ($class, $data) = @_;
     bless $data, $class;
 }
 
+=section Accessors
+
+=method start 
+Returns the (platform dependent) time value which represent the moment
+that the call was initiated.  See M<Time::HiRes> method C<time>.
+=cut
 
 sub start() {shift->{start}}
 
+=method date 
+Returns the date string which represent the moment that the call
+was initiated.
+=cut
 
 sub date() {scalar localtime shift->start}
 
+=method error [$error]
+Often contains an error message, when something went wrong.  The message
+is returned as M<Log::Report::Exception>.  Only the first error is returned,
+use M<errors()> to get all.
+
+[2.31] When an $error is provided, it is added to the internal list of errors.
+The $error parameter may be a M<Log::Report::Exception>, a
+M<Log::Report::Message> or a simple string.
+=cut
 
 sub error(;$)
 {   my $self   = shift;
@@ -48,24 +89,66 @@ sub error(;$)
     wantarray ? @$errors : $errors->[0];
 }
 
+=method errors 
+[2.31] Return all errors, which are M<Log::Report::Exception> objects.
+See also M<error()>.
+=cut
 
 sub errors() { @{shift->{errors} || []} }
 
+=method elapse [$kind]
+Returns the time in seconds (with hires, sub-second detail) of a part of
+the SOAP communication. Some values may be C<undef>.  Elapse without
+argument will return the total time elapsed.
+
+As KINDs are defined C<encode> (the time required by the translator
+build by XML::Compile::Schema to translate Perl into an XML::LibXML
+tree), C<transport>, and C<decode> (from XML::LibXML tree into Perl)>.
+The transport components are also provided separately, as C<stringify>
+(by XML::LibXML to convert a tree into text), C<connect> (for the network
+message exchange by HTTP::Daemon), and C<parse> (parsing answer string
+into XML)
+
+See M<printTimings()>.
+
+=example
+ print $trace->elapse('decode');
+=cut
 
 sub elapse($)
 {   my ($self, $kind) = @_;
     defined $kind ? $self->{$kind.'_elapse'} : $self->{elapse};
 }
 
+=method request 
+Returns the M<HTTP::Request> object used for this SOAP call.  This might
+be quite useful during debugging, because a lot of the processing is
+hidden for the user... but you may want to see or log what is actually
+begin send.
+=cut
 
 sub request() {shift->{http_request}}
 
+=method response 
+Returns the M<HTTP::Response> object, returned by the remote server.  In
+some erroneous cases, the client library will create an error response
+without any message was exchanged.
+=cut
 
 sub response() {shift->{http_response}}
 
+=method responseDOM 
+Returns the M<XML::LibXML::Document> top node of the response: the parsed
+text of the content of the received HTTP message.
+=cut
 
 sub responseDOM() {shift->{response_dom}}
 
+=section Printing
+
+=method printTimings [$fh]
+Print an overview on various timings to the selected filehandle.
+=cut
 
 sub printTimings(;$)
 {   my ($self, $fh) = @_;
@@ -91,6 +174,15 @@ sub printTimings(;$)
     select $oldfh if $oldfh;
 }
 
+=method printRequest [$fh], %options
+
+=option  pretty_print 0|1|2
+=default pretty_print 0
+Use M<XML::Compile::Transport::compileClient(xml_format)> if you want
+the messages to be shown readible.  The digits reflect XML::LibXML
+format settings: '0' is unchanged, '1' will show indented formatting,
+and '2' has even more whitespace in it.
+=cut
 
 sub printRequest(;$%)
 {   my $self    = shift;
@@ -113,6 +205,12 @@ sub printRequest(;$%)
     }
 }
 
+=method printResponse [$fh], %options
+=option  pretty_print 0|1|2
+=default pretty_print 0
+Use M<XML::Compile::Transport::compileClient(xml_format)> if you want
+the messages to be shown readible.
+=cut
 
 sub printResponse(;$%)
 {   my $self = shift;
@@ -136,6 +234,11 @@ sub printResponse(;$%)
     }
 }
 
+=method printErrors [$fh]
+The filehandle defaults to STDERR.
+
+If you want to see more output, try adding C<<use Log::Report mode => 3;>>
+=cut
 
 sub printErrors(;$)
 {   my ($self, $fh) = @_;
diff --git a/lib/XML/Compile/SOAP/Trace.pod b/lib/XML/Compile/SOAP/Trace.pod
deleted file mode 100644
index bda7c59..0000000
--- a/lib/XML/Compile/SOAP/Trace.pod
+++ /dev/null
@@ -1,168 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Trace - help displaying trace details.
-
-=head1 SYNOPSIS
-
- my ($answer, $trace) = $call->(%params);
- # now $trace is a XML::Compile::SOAP::Trace
-
- my $req = $trace->request;   # HTTP message which was sent
- my $res = $trace->response;  # HTTP message received
-
- my $start = $trace->date;
- my $dura  = $trace->elapse;
-
- $trace->printTimings;
- $trace->printErrors;
- $trace->printTimings(\*STDERR);
- $trace->printRequest(pretty_print => 1);
- $trace->printResponse;
-
-=head1 DESCRIPTION
-
-This help module simplifies user access to the trace data,
-as produced by a SOAP call (client side).
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item XML::Compile::SOAP::Trace-E<gt>B<new>(%options)
-
-Called by the SOAP call implementation; not for normal users.
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<date>()
-
-Returns the date string which represent the moment that the call
-was initiated.
-
-=item $obj-E<gt>B<elapse>( [$kind] )
-
-Returns the time in seconds (with hires, sub-second detail) of a part of
-the SOAP communication. Some values may be C<undef>.  Elapse without
-argument will return the total time elapsed.
-
-As KINDs are defined C<encode> (the time required by the translator
-build by XML::Compile::Schema to translate Perl into an XML::LibXML
-tree), C<transport>, and C<decode> (from XML::LibXML tree into Perl)>.
-The transport components are also provided separately, as C<stringify>
-(by XML::LibXML to convert a tree into text), C<connect> (for the network
-message exchange by HTTP::Daemon), and C<parse> (parsing answer string
-into XML)
-
-See L<printTimings()|XML::Compile::SOAP::Trace/"Printing">.
-
-example: 
-
- print $trace->elapse('decode');
-
-=item $obj-E<gt>B<error>( [$error] )
-
-Often contains an error message, when something went wrong.  The message
-is returned as Log::Report::Exception.  Only the first error is returned,
-use L<errors()|XML::Compile::SOAP::Trace/"Accessors"> to get all.
-
-[2.31] When an $error is provided, it is added to the internal list of errors.
-The $error parameter may be a Log::Report::Exception, a
-Log::Report::Message or a simple string.
-
-=item $obj-E<gt>B<errors>()
-
-[2.31] Return all errors, which are Log::Report::Exception objects.
-See also L<error()|XML::Compile::SOAP::Trace/"Accessors">.
-
-=item $obj-E<gt>B<request>()
-
-Returns the HTTP::Request object used for this SOAP call.  This might
-be quite useful during debugging, because a lot of the processing is
-hidden for the user... but you may want to see or log what is actually
-begin send.
-
-=item $obj-E<gt>B<response>()
-
-Returns the HTTP::Response object, returned by the remote server.  In
-some erroneous cases, the client library will create an error response
-without any message was exchanged.
-
-=item $obj-E<gt>B<responseDOM>()
-
-Returns the XML::LibXML::Document top node of the response: the parsed
-text of the content of the received HTTP message.
-
-=item $obj-E<gt>B<start>()
-
-Returns the (platform dependent) time value which represent the moment
-that the call was initiated.  See Time::HiRes method C<time>.
-
-=back
-
-=head2 Printing
-
-=over 4
-
-=item $obj-E<gt>B<printErrors>( [$fh] )
-
-The filehandle defaults to STDERR.
-
-If you want to see more output, try adding C<<use Log::Report mode => 3;>>
-
-=item $obj-E<gt>B<printRequest>( [$fh], %options )
-
- -Option      --Default
-  pretty_print  0
-
-=over 2
-
-=item pretty_print => 0|1|2
-
-Use L<XML::Compile::Transport::compileClient(xml_format)|XML::Compile::Transport/"Handlers"> if you want
-the messages to be shown readible.  The digits reflect XML::LibXML
-format settings: '0' is unchanged, '1' will show indented formatting,
-and '2' has even more whitespace in it.
-
-=back
-
-=item $obj-E<gt>B<printResponse>( [$fh], %options )
-
- -Option      --Default
-  pretty_print  0
-
-=over 2
-
-=item pretty_print => 0|1|2
-
-Use L<XML::Compile::Transport::compileClient(xml_format)|XML::Compile::Transport/"Handlers"> if you want
-the messages to be shown readible.
-
-=back
-
-=item $obj-E<gt>B<printTimings>( [$fh] )
-
-Print an overview on various timings to the selected filehandle.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP/Util.pm b/lib/XML/Compile/SOAP/Util.pm
index 6e51b7e..82fd674 100644
--- a/lib/XML/Compile/SOAP/Util.pm
+++ b/lib/XML/Compile/SOAP/Util.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP::Util;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'Exporter';
 
 use warnings;
@@ -30,6 +23,27 @@ our %EXPORT_TAGS =
   , xop10  => \@xop10
   );
 
+=chapter NAME
+XML::Compile::SOAP::Util - general purpose routines for XML::Compile::SOAP
+
+=chapter SYNOPSIS
+ use XML::Compile::SOAP::Util qw/:soap11 WSDL11/;
+
+=chapter DESCRIPTION
+This module collects functions which are useful on many places in the
+SOAP implementation, just as M<XML::Compile::Util> does for general XML
+implementations (often you will needs things from both).
+
+On the moment, only a long list of constant URIs are exported.
+
+=chapter FUNCTIONS
+
+=section Constants
+The export TAG C<:soap11> groups the SOAP version 1.1 related exported
+constants C<SOAP11ENV>, C<SOAP11ENC>, actor C<SOAP11NEXT>, and http
+indicator C<SOAP11HTTP>.
+
+=cut
 
 use constant SOAP11 => 'http://schemas.xmlsoap.org/soap/';
 use constant
@@ -39,6 +53,12 @@ use constant
   , SOAP11HTTP      => SOAP11. 'http'
   };
 
+=pod
+The export TAG C<:wsdl11> groups the exported WSDL version 1.1 related
+constants C<WSDL11>, C<WSDL11SOAP>, C<WSDL11HTTP>, C<WSDL11MIME>,
+C<WSDL11SOAP12>.
+
+=cut
 
 use constant WSDL11 => 'http://schemas.xmlsoap.org/wsdl/';
 use constant
@@ -48,6 +68,13 @@ use constant
   , WSDL11SOAP12    => WSDL11. 'soap12/'
   };
  
+=pod
+The export TAG C<:daemon> refers currently only to the constant C<MSEXT>,
+which refers to the MicroSoft Extension Framework namespace.
+
+Besides, this tag also defines namespaces for server implementations:
+C<XC_DAEMON_NS> refers to the M<XML::Compile::SOAP::Daemon> server.
+=cut
 
 use constant
   { MSEXT           => SOAP11ENV
@@ -55,6 +82,9 @@ use constant
   };
 
 
+=pod
+The export TAG C<:xop10> refers to C<XOP10>, C<XMIME10> and C<XMIME11>
+=cut
 
 use constant
   { XOP10           => 'http://www.w3.org/2004/08/xop/include'
diff --git a/lib/XML/Compile/SOAP/Util.pod b/lib/XML/Compile/SOAP/Util.pod
deleted file mode 100644
index dee3e49..0000000
--- a/lib/XML/Compile/SOAP/Util.pod
+++ /dev/null
@@ -1,62 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP::Util - general purpose routines for XML::Compile::SOAP
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP::Util
-   is a Exporter
-
-=head1 SYNOPSIS
-
- use XML::Compile::SOAP::Util qw/:soap11 WSDL11/;
-
-=head1 DESCRIPTION
-
-This module collects functions which are useful on many places in the
-SOAP implementation, just as L<XML::Compile::Util|XML::Compile::Util> does for general XML
-implementations (often you will needs things from both).
-
-On the moment, only a long list of constant URIs are exported.
-
-=head1 FUNCTIONS
-
-=head2 Constants
-
-The export TAG C<:soap11> groups the SOAP version 1.1 related exported
-constants C<SOAP11ENV>, C<SOAP11ENC>, actor C<SOAP11NEXT>, and http
-indicator C<SOAP11HTTP>.
-
-=pod
-
-The export TAG C<:wsdl11> groups the exported WSDL version 1.1 related
-constants C<WSDL11>, C<WSDL11SOAP>, C<WSDL11HTTP>, C<WSDL11MIME>,
-C<WSDL11SOAP12>.
-
-=pod
-
-The export TAG C<:daemon> refers currently only to the constant C<MSEXT>,
-which refers to the MicroSoft Extension Framework namespace.
-
-Besides, this tag also defines namespaces for server implementations:
-C<XC_DAEMON_NS> refers to the L<XML::Compile::SOAP::Daemon|XML::Compile::SOAP::Daemon> server.
-
-=pod
-
-The export TAG C<:xop10> refers to C<XOP10>, C<XMIME10> and C<XMIME11>
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP11.pm b/lib/XML/Compile/SOAP11.pm
index f029fe0..6d8fee4 100644
--- a/lib/XML/Compile/SOAP11.pm
+++ b/lib/XML/Compile/SOAP11.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP11;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::SOAP';
 
 use warnings;
@@ -28,6 +21,34 @@ __PACKAGE__->register
   , &SOAP11ENV => 'XML::Compile::SOAP11::Operation'
   );
 
+=chapter NAME
+XML::Compile::SOAP11 - SOAP 1.1 protocol
+
+=chapter SYNOPSIS
+ # use either XML::Compile::SOAP11::Client or ::Server
+ # See XML::Compile::SOAP for global usage examples.
+
+=chapter DESCRIPTION
+This module handles the SOAP protocol version 1.1.
+See F<http://www.w3.org/TR/2000/NOTE-SOAP-20000508/>).
+The implementation tries to behave like described in
+F<http://www.ws-i.org/Profiles/BasicProfile-1.0.html>
+
+Two extensions are made: the SOAP11 client
+M<XML::Compile::SOAP11::Client>.
+and server in M<XML::Compile::SOAP11::Server>.
+
+=chapter METHODS
+
+=section Constructors
+
+=method new %options
+To simplify the URIs of the actors, as specified with the C<destination>
+option, you may use the STRING C<NEXT>.  It will be replaced by the
+right URI.
+
+=default media_type C<text/xml>
+=cut
 
 sub new($@)
 {   my $class = shift;
@@ -85,6 +106,17 @@ sub envType($) { pack_type SOAP11ENV, $_[1] }
 
 #-----------------------------------
 
+=section Single message
+
+=method compileMessage <'SENDER'|'RECEIVER'>, %options
+
+=option  headerfault ENTRIES
+=default headerfault []
+ARRAY of simple name with element references, for all expected
+faults.  There can be unexpected faults, which will not get
+decoded automatically.
+
+=cut
 
 sub compileMessage($$)
 {   my ($self, $direction, %args) = @_;
@@ -374,8 +406,171 @@ sub roleAbbreviation($) { $_[1] && $_[1] eq SOAP11NEXT ? 'NEXT' : $_[1] }
 
 #-------------------------------------
 # docs of ::SOAP11::Encoding inserted here
+=subsection Encoding
+=subsection Decoding
+=cut
 
 #-------------------------------------
 
+=chapter DETAILS
+
+=section Header and Body entries
+
+You only call M<compileMessage()> explicitly if you do not have a WSDL
+file which contains this information. In the unlucky situation, you
+have to dig out the defined types by hand.
+
+But even with a WSDL, there are still a few problems you may encounter.
+For instance, the WSDL will not contain C<mustUnderstand> and C<actor>
+header routing information.  You can add these to the compileClient call
+
+  my $call = $wsdl->compileClient
+    ( 'MyCall'
+    , mustUnderstand => 'h1'
+    , destination    => [ h1 => 'NEXT' ]
+    );
+
+=subsection Simplest form
+
+In the simplest form, the C<header> and C<body> refer (optionally) to a
+list of PAIRS, each containing a free to choose unique label and the
+type of the element.  The unique label will be used in the Perl HASH
+which represents the message.
+
+ my $h1el = pack_type $myns, $some_local;
+ my $b1el = 'myprefix:$other_local';
+
+ my $encode_query = $client->compileMessage
+   ( 'SENDER'
+   , header   => [ h1 => $h1el ]
+   , body     => [ b1 => $b1el ]
+   , mustUnderstand => 'h1'
+   , destination    => [ h1 => 'NEXT' ]
+   );
+
+=subsection Most powerful form
+
+When the simple form is too simple, you can use a HASH for the header,
+body or both.  The HASH structure is much like the WSDL structure.
+For example:
+
+ my $encode_query = $client->compileMessage
+   ( 'SENDER'
+   , header   =>
+      { use   => 'literal'
+      , parts => [ { name => 'h1', element => $h1el
+                   , mustUnderstand => 1, destination => 'NEXT'
+                   } ]
+      }
+   , body     => [ b1 => $b1el ]
+   );
+
+So, the header now is one HASH, which tells us that we have a literal
+definition (this is the default).  The optional parts for the header is
+an ARRAY of HASHes, each describing one part.  As you can see, the
+mustUnderstand and destination fields are more convenient (although
+the other syntax will work as well).
+
+If you feel the need to control the compilation of the various parts,
+with hooks or options (see M<XML::Compile::Schema::compile()>), then have
+a look at M<XML::Compile::Cache::declare()>.  Declare how to handle the
+various types before you call M<compileMessage()>.
+
+=section Receiving faults in SOAP1.1
+
+When faults are received, they will be returned with the C<Fault> key
+in the data structure.  So:
+
+  my $answer = $call->($question);
+  if($answer->{Fault}) { ... }
+
+As extra service, for each of the fault types, as defined with
+M<compileMessage(faults)>, a decoded structure is included.  The name
+of that structure can be found like this:
+
+  if(my $faults = $answer->{Fault})
+  {   my $name    = $faults->{_NAME};
+      my $decoded = $answer->{$name};
+      ...
+  }
+
+The untranslated C<$faults> HASH looks like this:
+
+ Fault =>
+   { faultcode => '{http://schemas.xmlsoap.org/soap/envelope/}Server.first'
+   , faultstring => 'my mistake'
+   , faultactor => 'http://schemas.xmlsoap.org/soap/actor/next'
+   , detail => { '{http://test-types}fault_one' => [ XMLNODES ] }
+   , _NAME => 'fault1'
+   }
+
+The C<_NAME> originates from the M<compileMessage(faults)> option:
+
+   $soap->compileMessage('RECEIVER', ...
+     , faults => [ fault1 => '{http://test-types}fault_one' ] );
+
+Now, automatically the answer will contain the decoded fault
+structure as well:
+
+  fault1 =>
+    { code => '{http://schemas.xmlsoap.org/soap/envelope/}Server.first'
+    , class  => [ 'http://schemas.xmlsoap.org/soap/envelope/'
+         , 'Receiver', 'first' ]
+    , reason => 'my mistake',
+    , role   => 'NEXT'
+    , detail => { help => 'please ignore' }
+    }
+
+The C<detail> is the decoding of the XMLNODES, which are defined to
+be of type C<< {http://test-types}fault_one >>.
+
+The C<class> is an unpacked version of the code.  SOAP1.2 is using the
+(better) terms C<Sender> and C<Receiver>.
+
+C<role> is constructed by decoding the C<faultactor> using
+M<roleAbbreviation()>.  The names are closer to the SOAP1.2 specification.
+
+If the received fault is of an unpredicted type, then the client tries
+to DWIM. in the worst case, C<detail> will list the unparsed XMLNODEs.
+When the M<XML::Compile::SOAP::Daemon> server has produced the error,
+the content of the reply will typically be
+
+ { Fault =>        # SOAP version specific
+    { _NAME => 'error'
+    , #...more...
+    }
+ , error =>        # less SOAP version specific, readable
+    { role    => 'NEXT'
+    , reason  => 'procedure xyz for SOAP11 produced an invalid response'
+    , error   => 'some explanation'
+    , code    =>
+        '{http://schemas.xmlsoap.org/soap/envelope/}Server.invalidResponse'
+    , class   => [ SOAP11ENV, 'Receiver', 'invalidResponse' ],
+    }
+  }
+
+Hence, a typical client routine could contain
+
+  my ($answer, $trace) = $call->(message => $message);
+  if(my $f = $answer->{Fault})
+  {   if($f->{_NAME} eq 'error')
+      {   # server implementation error
+          die "SERVER ERROR:\n$answer->{error}{error}\n";
+      }
+      else
+      {   # the fault is described in the WSDL, handle it!
+          warn "FAULT:\n",Dumper $answer->{$f->{_NAME}};
+      }
+  }
+  else
+  {   # correct answer
+      print Dumper $answer;
+  }
+
+Or
+
+  my ($answer, $trace) = $call->(message => $message);
+  $answer or die $trace->error;
+=cut
 
 1;
diff --git a/lib/XML/Compile/SOAP11.pod b/lib/XML/Compile/SOAP11.pod
deleted file mode 100644
index 50c5d92..0000000
--- a/lib/XML/Compile/SOAP11.pod
+++ /dev/null
@@ -1,362 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP11 - SOAP 1.1 protocol
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP11 has extra code in
-   XML::Compile::SOAP11::Encoding
-
- XML::Compile::SOAP11
-   is a XML::Compile::SOAP
-
- XML::Compile::SOAP11 is extended by
-   XML::Compile::SOAP11::Client
-   XML::Compile::SOAP11::Server
-
-=head1 SYNOPSIS
-
- # use either XML::Compile::SOAP11::Client or ::Server
- # See XML::Compile::SOAP for global usage examples.
-
-=head1 DESCRIPTION
-
-This module handles the SOAP protocol version 1.1.
-See F<http://www.w3.org/TR/2000/NOTE-SOAP-20000508/>).
-The implementation tries to behave like described in
-F<http://www.ws-i.org/Profiles/BasicProfile-1.0.html>
-
-Two extensions are made: the SOAP11 client
-L<XML::Compile::SOAP11::Client|XML::Compile::SOAP11::Client>.
-and server in L<XML::Compile::SOAP11::Server|XML::Compile::SOAP11::Server>.
-
-Extends L<"DESCRIPTION" in XML::Compile::SOAP|XML::Compile::SOAP/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::SOAP|XML::Compile::SOAP/"METHODS">.
- 
-=head2 Constructors
-
-Extends L<"Constructors" in XML::Compile::SOAP|XML::Compile::SOAP/"Constructors">.
- 
-=over 4
-
-=item $obj-E<gt>B<new>(%options)
-
-To simplify the URIs of the actors, as specified with the C<destination>
-option, you may use the STRING C<NEXT>.  It will be replaced by the
-right URI.
-
- -Option    --Defined in        --Default
-  media_type  XML::Compile::SOAP  text/xml
-  schemas     XML::Compile::SOAP  created internally
-
-=over 2
-
-=item media_type => MIMETYPE
-
-=item schemas => C<XML::Compile::Cache> object
-
-=back
-
-=item XML::Compile::SOAP11-E<gt>B<register>($uri, $envns)
-
-Inherited, see L<XML::Compile::SOAP/"Constructors">
-
-=back
-
-=head2 Accessors
-
-Extends L<"Accessors" in XML::Compile::SOAP|XML::Compile::SOAP/"Accessors">.
- 
-=over 4
-
-=item $obj-E<gt>B<mediaType>()
-
-Inherited, see L<XML::Compile::SOAP/"Accessors">
-
-=item $obj-E<gt>B<schemas>()
-
-Inherited, see L<XML::Compile::SOAP/"Accessors">
-
-=item $obj-E<gt>B<version>()
-
-Inherited, see L<XML::Compile::SOAP/"Accessors">
-
-=back
-
-=head2 Single message
-
-Extends L<"Single message" in XML::Compile::SOAP|XML::Compile::SOAP/"Single message">.
- 
-=over 4
-
-=item $obj-E<gt>B<compileMessage>( <'SENDER'|'RECEIVER'>, %options )
-
- -Option        --Defined in        --Default
-  body            XML::Compile::SOAP  []
-  destination     XML::Compile::SOAP  []
-  faults          XML::Compile::SOAP  []
-  header          XML::Compile::SOAP  undef
-  headerfault                         []
-  mustUnderstand  XML::Compile::SOAP  []
-  procedure       XML::Compile::SOAP  undef
-  role            XML::Compile::SOAP  ULTIMATE
-  roles           XML::Compile::SOAP  []
-
-=over 2
-
-=item body => ENTRIES|HASH
-
-=item destination => ARRAY-OF-PAIRS
-
-=item faults => ENTRIES|HASH
-
-=item header => ENTRIES|HASH
-
-=item headerfault => ENTRIES
-
-ARRAY of simple name with element references, for all expected
-faults.  There can be unexpected faults, which will not get
-decoded automatically.
-
-=item mustUnderstand => STRING|ARRAY-OF-STRING
-
-=item procedure => TYPE
-
-=item role => URI|ARRAY-OF-URI
-
-=item roles => ARRAY-OF-URI
-
-=back
-
-=item $obj-E<gt>B<messageStructure>($xml)
-
-=item XML::Compile::SOAP11-E<gt>B<messageStructure>($xml)
-
-Inherited, see L<XML::Compile::SOAP/"Single message">
-
-=back
-
-=head2 Helpers
-
-Extends L<"Helpers" in XML::Compile::SOAP|XML::Compile::SOAP/"Helpers">.
- 
-=head2 Transcoding
-
-Extends L<"Transcoding" in XML::Compile::SOAP|XML::Compile::SOAP/"Transcoding">.
- 
-=over 4
-
-=item $obj-E<gt>B<replyMustUnderstandFault>($type)
-
-Inherited, see L<XML::Compile::SOAP/"Transcoding">
-
-=item $obj-E<gt>B<roleAbbreviation>($uri)
-
-Inherited, see L<XML::Compile::SOAP/"Transcoding">
-
-=item $obj-E<gt>B<roleURI>($uri|STRING)
-
-Inherited, see L<XML::Compile::SOAP/"Transcoding">
-
-=back
-
-=head1 DETAILS
-
-Extends L<"DETAILS" in XML::Compile::SOAP|XML::Compile::SOAP/"DETAILS">.
- 
-=head2 SOAP introduction
-
-Extends L<"SOAP introduction" in XML::Compile::SOAP|XML::Compile::SOAP/"SOAP introduction">.
- 
-=head2 Supported servers
-
-Extends L<"Supported servers" in XML::Compile::SOAP|XML::Compile::SOAP/"Supported servers">.
- 
-=head2 Naming types and elements
-
-Extends L<"Naming types and elements" in XML::Compile::SOAP|XML::Compile::SOAP/"Naming types and elements">.
- 
-=head2 Client and Server implementations
-
-Extends L<"Client and Server implementations" in XML::Compile::SOAP|XML::Compile::SOAP/"Client and Server implementations">.
- 
-=head2 Use of wildcards (any and anyAttribute)
-
-Extends L<"Use of wildcards (any and anyAttribute)" in XML::Compile::SOAP|XML::Compile::SOAP/"Use of wildcards (any and anyAttribute)">.
- 
-=head2 Header and Body entries
-
-You only call L<compileMessage()|XML::Compile::SOAP11/"Single message"> explicitly if you do not have a WSDL
-file which contains this information. In the unlucky situation, you
-have to dig out the defined types by hand.
-
-But even with a WSDL, there are still a few problems you may encounter.
-For instance, the WSDL will not contain C<mustUnderstand> and C<actor>
-header routing information.  You can add these to the compileClient call
-
-  my $call = $wsdl->compileClient
-    ( 'MyCall'
-    , mustUnderstand => 'h1'
-    , destination    => [ h1 => 'NEXT' ]
-    );
-
-=head3 Simplest form
-
-In the simplest form, the C<header> and C<body> refer (optionally) to a
-list of PAIRS, each containing a free to choose unique label and the
-type of the element.  The unique label will be used in the Perl HASH
-which represents the message.
-
- my $h1el = pack_type $myns, $some_local;
- my $b1el = 'myprefix:$other_local';
-
- my $encode_query = $client->compileMessage
-   ( 'SENDER'
-   , header   => [ h1 => $h1el ]
-   , body     => [ b1 => $b1el ]
-   , mustUnderstand => 'h1'
-   , destination    => [ h1 => 'NEXT' ]
-   );
-
-=head3 Most powerful form
-
-When the simple form is too simple, you can use a HASH for the header,
-body or both.  The HASH structure is much like the WSDL structure.
-For example:
-
- my $encode_query = $client->compileMessage
-   ( 'SENDER'
-   , header   =>
-      { use   => 'literal'
-      , parts => [ { name => 'h1', element => $h1el
-                   , mustUnderstand => 1, destination => 'NEXT'
-                   } ]
-      }
-   , body     => [ b1 => $b1el ]
-   );
-
-So, the header now is one HASH, which tells us that we have a literal
-definition (this is the default).  The optional parts for the header is
-an ARRAY of HASHes, each describing one part.  As you can see, the
-mustUnderstand and destination fields are more convenient (although
-the other syntax will work as well).
-
-If you feel the need to control the compilation of the various parts,
-with hooks or options (see L<XML::Compile::Schema::compile()|XML::Compile::Schema/"Compilers">), then have
-a look at L<XML::Compile::Cache::declare()|XML::Compile::Cache/"Administration">.  Declare how to handle the
-various types before you call L<compileMessage()|XML::Compile::SOAP11/"Single message">.
-
-=head2 Receiving faults in SOAP1.1
-
-When faults are received, they will be returned with the C<Fault> key
-in the data structure.  So:
-
-  my $answer = $call->($question);
-  if($answer->{Fault}) { ... }
-
-As extra service, for each of the fault types, as defined with
-L<compileMessage(faults)|XML::Compile::SOAP/"Single message">, a decoded structure is included.  The name
-of that structure can be found like this:
-
-  if(my $faults = $answer->{Fault})
-  {   my $name    = $faults->{_NAME};
-      my $decoded = $answer->{$name};
-      ...
-  }
-
-The untranslated C<$faults> HASH looks like this:
-
- Fault =>
-   { faultcode => '{http://schemas.xmlsoap.org/soap/envelope/}Server.first'
-   , faultstring => 'my mistake'
-   , faultactor => 'http://schemas.xmlsoap.org/soap/actor/next'
-   , detail => { '{http://test-types}fault_one' => [ XMLNODES ] }
-   , _NAME => 'fault1'
-   }
-
-The C<_NAME> originates from the L<compileMessage(faults)|XML::Compile::SOAP/"Single message"> option:
-
-   $soap->compileMessage('RECEIVER', ...
-     , faults => [ fault1 => '{http://test-types}fault_one' ] );
-
-Now, automatically the answer will contain the decoded fault
-structure as well:
-
-  fault1 =>
-    { code => '{http://schemas.xmlsoap.org/soap/envelope/}Server.first'
-    , class  => [ 'http://schemas.xmlsoap.org/soap/envelope/'
-         , 'Receiver', 'first' ]
-    , reason => 'my mistake',
-    , role   => 'NEXT'
-    , detail => { help => 'please ignore' }
-    }
-
-The C<detail> is the decoding of the XMLNODES, which are defined to
-be of type C<< {http://test-types}fault_one >>.
-
-The C<class> is an unpacked version of the code.  SOAP1.2 is using the
-(better) terms C<Sender> and C<Receiver>.
-
-C<role> is constructed by decoding the C<faultactor> using
-L<roleAbbreviation()|XML::Compile::SOAP/"Transcoding">.  The names are closer to the SOAP1.2 specification.
-
-If the received fault is of an unpredicted type, then the client tries
-to DWIM. in the worst case, C<detail> will list the unparsed XMLNODEs.
-When the L<XML::Compile::SOAP::Daemon|XML::Compile::SOAP::Daemon> server has produced the error,
-the content of the reply will typically be
-
- { Fault =>        # SOAP version specific
-    { _NAME => 'error'
-    , #...more...
-    }
- , error =>        # less SOAP version specific, readable
-    { role    => 'NEXT'
-    , reason  => 'procedure xyz for SOAP11 produced an invalid response'
-    , error   => 'some explanation'
-    , code    =>
-        '{http://schemas.xmlsoap.org/soap/envelope/}Server.invalidResponse'
-    , class   => [ SOAP11ENV, 'Receiver', 'invalidResponse' ],
-    }
-  }
-
-Hence, a typical client routine could contain
-
-  my ($answer, $trace) = $call->(message => $message);
-  if(my $f = $answer->{Fault})
-  {   if($f->{_NAME} eq 'error')
-      {   # server implementation error
-          die "SERVER ERROR:\n$answer->{error}{error}\n";
-      }
-      else
-      {   # the fault is described in the WSDL, handle it!
-          warn "FAULT:\n",Dumper $answer->{$f->{_NAME}};
-      }
-  }
-  else
-  {   # correct answer
-      print Dumper $answer;
-  }
-
-Or
-
-  my ($answer, $trace) = $call->(message => $message);
-  $answer or die $trace->error;
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP11/Client.pm b/lib/XML/Compile/SOAP11/Client.pm
index e2a0e54..a354a3f 100644
--- a/lib/XML/Compile/SOAP11/Client.pm
+++ b/lib/XML/Compile/SOAP11/Client.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP11::Client;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::SOAP11','XML::Compile::SOAP::Client';
 
 use warnings;
@@ -19,5 +12,19 @@ use Log::Report   'xml-compile-soap';
 
 use XML::Compile::Util qw/unpack_type/;
 
+=chapter NAME
+XML::Compile::SOAP11::Client - SOAP1.1 client needs
+
+=chapter SYNOPSIS
+
+=chapter DESCRIPTION
+See M<XML::Compile::SOAP11>.
+
+=chapter METHODS
+
+=section Constructors
+
+=section Handlers
+=cut
 
 1;
diff --git a/lib/XML/Compile/SOAP11/Client.pod b/lib/XML/Compile/SOAP11/Client.pod
deleted file mode 100644
index a6132f0..0000000
--- a/lib/XML/Compile/SOAP11/Client.pod
+++ /dev/null
@@ -1,48 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP11::Client - SOAP1.1 client needs
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP11::Client
-   is a XML::Compile::SOAP11
-   is a XML::Compile::SOAP
-
- XML::Compile::SOAP11::Client
-   is a XML::Compile::SOAP::Client
-
-=head1 SYNOPSIS
-
-=head1 DESCRIPTION
-
-See L<XML::Compile::SOAP11|XML::Compile::SOAP11>.
-
-Extends L<"DESCRIPTION" in XML::Compile::SOAP::Client|XML::Compile::SOAP::Client/"DESCRIPTION">.
- 
-Extends L<"DESCRIPTION" in XML::Compile::SOAP11|XML::Compile::SOAP11/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::SOAP::Client|XML::Compile::SOAP::Client/"METHODS">.
- 
-Extends L<"METHODS" in XML::Compile::SOAP11|XML::Compile::SOAP11/"METHODS">.
- 
-=head1 DETAILS
-
-Extends L<"DETAILS" in XML::Compile::SOAP11|XML::Compile::SOAP11/"DETAILS">.
- 
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP11/Encoding.pm b/lib/XML/Compile/SOAP11/Encoding.pm
index 2f212db..7ad8c96 100644
--- a/lib/XML/Compile/SOAP11/Encoding.pm
+++ b/lib/XML/Compile/SOAP11/Encoding.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
-package XML::Compile::SOAP11;
-use vars '$VERSION';
-$VERSION = '3.27';
-  #!!!
+package XML::Compile::SOAP11;  #!!!
 
 use warnings;
 use strict;
@@ -29,6 +22,26 @@ sub XML::Compile::SOAP11::Encoding::import(@) #!!!
     $simplify = $args{simplify};
 }
 
+=chapter NAME
+XML::Compile::SOAP11::Encoding - SOAP encoding
+
+=chapter SYNOPSIS
+ ### This module may work for you... but may also
+ ### not work.  Progress has been made, but the
+ ### implementation is not complete and not well tested.
+
+ # Add this to load the logic
+ use XML::Compile::SOAP11::Encoding simplify => 1;
+
+ # The internals are used by the ::SOAP11 module, and
+ # probably should not be called by yourself.
+
+=chapter DESCRIPTION
+This module loads extra functionality into the M<XML::Compile::SOAP11>
+namespace: all kinds of methods which are used to SOAP-encode data.
+
+=chapter METHODS
+=cut
 
 sub _initRpcEnc11($$)
 {   my ($self, $schemas, $xsddir) = @_;
@@ -85,7 +98,17 @@ sub _writer_body_rpcenc_hook($$$$$)
 }
 
 #------------------
+=section Transcoding
+SOAP defines encodings, especially for SOAP-RPC.
 
+=subsection Encoding
+=cut
+
+=method startEncoding %options
+=option  doc XML::LibXML::Document node
+=default doc <created internally with utf8>
+
+=cut
 
 sub startEncoding(%)
 {   my ($self, %args) = @_;
@@ -138,12 +161,32 @@ sub _enc_array_hook(@)
     $elem;
 }
 
+=method prefixed $type|<$ns,$local>
+Translate a $ns-$local combination (which may be represented as
+a packed $type) into a prefixed notation.
+=cut
 
 sub prefixed($;$)
 {   my $self = shift;
     $self->schemas->prefixed(@_);
 }
 
+=method enc $local, $value, [$id]
+In the SOAP specification, encoding types are defined: elements
+which do not have a distinguishable name but use the type of the
+data as name.  Yep, ugly!
+
+=example
+  my $xml = $soap->enc('int', 43);
+  my $xml = $soap->enc(int => 43);
+  print $xml->toString;
+    # <SOAP-ENC:int>43</SOAP-ENC:int>
+
+  my $xml = $soap->enc('int', 42, id => 'me');
+  my $xml = $soap->enc(int => 42, id => 'me');
+  print $xml->toString;
+    # <SOAP-ENC:int id="me">42</SOAP-ENC:int>
+=cut
 
 sub enc($$$)
 {   my ($self, $local, $value, $id) = @_;
@@ -152,6 +195,28 @@ sub enc($$$)
          ->($self->{enc}{doc}, {_ => $value, id => $id} );
 }
 
+=method typed $type, $name, $value
+A "typed" element shows its type explicitly, via the "xsi:type" attribute.
+The $value will get processed via an auto-generated XML::Compile writer,
+so validated.  The processing is cashed.
+
+When $value already is an M<XML::LibXML::Element>, then no processing
+nor value checking will be performed.  The $name will be ignored.
+
+If the $type is not qualified, then it is interpreted as basic type, as
+defined by the selected schema.  If you explicitly
+need a non-namespace typed item, then use an empty namespace.  In any
+case, the type must be defined and the value is validated.
+
+=examples
+
+ my $xml = $soap->typed(int => count => 5);
+ my $xml = $soap->typed(pack_type(SCHEMA1999, 'int'), count => 5);
+
+ my $xml = $soap->typed(pack_type('', 'mine'), a => 1);
+ my $xml = $soap->typed('{}mine'), a => 1); #same
+
+=cut
 
 sub typed($$$)
 {   my ($self, $type, $name, $value) = @_;
@@ -175,6 +240,10 @@ sub typed($$$)
     $el;
 }
 
+=method struct $type, $childs
+Create a structure, an element with children.  The $childs must be fully
+prepared M<XML::LibXML::Element> objects.
+=cut
 
 sub struct($@)
 {   my ($self, $type, @childs) = @_;
@@ -185,6 +254,15 @@ sub struct($@)
     $struct;
 }
 
+=method element $type, $name, $value
+Create an element.  The $name is for node, where a namespace component
+is translated into a prefix.  When you wish for a C<type> attribute,
+use M<typed()>.
+
+When the $type does not contain a namespace indication, it is taken
+in the selected schema namespace.  If the $value already is a
+M<XML::LibXML::Element>, then that one is used (and the $name ignored).
+=cut
 
 sub element($$$)
 {   my ($self, $type, $name, $value) = @_;
@@ -203,6 +281,11 @@ sub element($$$)
     $el;
 }
 
+=method href $name, $element, [$id]
+Create a reference element with $name to the existing $element.  When the
+$element does not have an "id" attribute yet, then $id will be used.  In
+case not $id was specified, then one is generated.
+=cut
 
 my $id_count = 0;
 sub href($$$)
@@ -219,6 +302,13 @@ sub href($$$)
     $el;
 }
 
+=method nil [$type], $name
+Create an element with $name which explicitly has the C<xsi:nil> attribute.
+If the $name is full (has a namespace to it), it will be translated into
+a QNAME, otherwise, it is considered not namespace qualified.
+
+If a $type is given, then an explicit type parameter is added.
+=cut
 
 sub nil($;$)
 {   my $self = shift;
@@ -237,6 +327,59 @@ sub nil($;$)
     $el;
 }
 
+=method array <$name|undef>, $item_type, $elements, %options
+Arrays can be a mess: a mixture of anything and nothing.  Therefore,
+you have to help the generation more than you may wish for.  This
+method produces an one dimensional array, M<multidim()> is used for
+multi-dimensional arrays.
+
+The $name is the packed type of the array itself.  When undef,
+the C<< {soap-enc-ns}Array >> will be used (the action soap
+encoding namespace will be used).
+
+The $item_type specifies the type of each element within the array.
+This type is used to create the C<arrayType> attribute, however
+doesn't tell enough about the items themselves: they may be
+extensions to that type.
+
+Each of the $elements (passed as ARRAY) must be an M<XML::LibXML::Node>,
+either self-constructed, or produced by one of the builder methods in
+this class, like M<enc()> or M<typed()>.
+
+Returned is the XML::LibXML::Element which represents the
+array.
+
+=option  offset INTEGER
+=default offset 0
+When a partial array is to be transmitted, the number of the base
+element.
+
+=option  slice INTEGER
+=default slice <all remaining>
+When a partial array is to be transmitted, this is the length of
+the slice to be sent (the number of elements starting with the C<offset>
+element)
+
+=option  id STRING
+=default id <undef>
+Assign an id to the array.  If not defined, than no id attribute is
+added.
+
+=option  array_type STRING
+=default array_type <generated>
+The arrayType attribute content.  When explicitly set to undef, the
+attribute is not created.
+
+=option  nested_array STRING
+=default nested_array ''
+The ARRAY type should reflect nested array structures if they are
+homogeneous.  This is a really silly part of the specs, because there
+is no need for it on any other comparible place in the specs... but ala.
+
+For instance: C<< nested_array => '[,]' >>, means that this array
+contains two-dimensional arrays.
+
+=cut
 
 sub array($$$@)
 {   my ($self, $name, $itemtype, $array, %opts) = @_;
@@ -288,6 +431,18 @@ sub array($$$@)
     $el;
 }
 
+=method multidim <$name|undef>, $item_type, $elements, %options
+A multi-dimensional array, less flexible than a single dimensional
+array, which can be created with M<array()>.
+
+The table of $elements (ARRAY of ARRAYs) must be full: in each of the
+dimensions, the length of each row must be the same.  On the other
+hand, it may be sparse (contain undefs).  The size of each dimension is
+determined by the length of its first element.
+
+=option  id STRING
+=default id C<undef>
+=cut
 
 sub multidim($$$@)
 {   my ($self, $name, $itemtype, $array, %opts) = @_;
@@ -376,6 +531,19 @@ sub _flatten_multidim($$$)
 }
 
 #--------------------------------------------------
+=subsection Decoding
+
+=method rpcDecode $xmlnodes
+Decode the elements found in the $xmlnodes (list of M<XML::LibXML::Node>
+objects).  Use Data::Dumper to figure-out what the produced output is:
+it is a guess, so may not be perfect (do not use RPC but document style
+soap for good results).
+
+The decoded data is returned.  When "simplify" is set, then the returned
+data is compact but may be sloppy.  Otherwise, a HASH is returned
+containing as much info as could be extracted from the tree.
+
+=cut
 
 sub rpcDecode(@)
 {   my $self  = shift;
diff --git a/lib/XML/Compile/SOAP11/Encoding.pod b/lib/XML/Compile/SOAP11/Encoding.pod
deleted file mode 100644
index 698cc6e..0000000
--- a/lib/XML/Compile/SOAP11/Encoding.pod
+++ /dev/null
@@ -1,233 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP11::Encoding - SOAP encoding
-
-=head1 SYNOPSIS
-
- ### This module may work for you... but may also
- ### not work.  Progress has been made, but the
- ### implementation is not complete and not well tested.
-
- # Add this to load the logic
- use XML::Compile::SOAP11::Encoding simplify => 1;
-
- # The internals are used by the ::SOAP11 module, and
- # probably should not be called by yourself.
-
-=head1 DESCRIPTION
-
-This module loads extra functionality into the L<XML::Compile::SOAP11|XML::Compile::SOAP11>
-namespace: all kinds of methods which are used to SOAP-encode data.
-
-=head1 METHODS
-
-=head2 Transcoding
-
-SOAP defines encodings, especially for SOAP-RPC.
-
-=head3 Encoding
-
-=over 4
-
-=item $obj-E<gt>B<array>( <$name|undef>, $item_type, $elements, %options )
-
-Arrays can be a mess: a mixture of anything and nothing.  Therefore,
-you have to help the generation more than you may wish for.  This
-method produces an one dimensional array, L<multidim()|XML::Compile::SOAP11::Encoding/"Encoding"> is used for
-multi-dimensional arrays.
-
-The $name is the packed type of the array itself.  When undef,
-the C<< {soap-enc-ns}Array >> will be used (the action soap
-encoding namespace will be used).
-
-The $item_type specifies the type of each element within the array.
-This type is used to create the C<arrayType> attribute, however
-doesn't tell enough about the items themselves: they may be
-extensions to that type.
-
-Each of the $elements (passed as ARRAY) must be an XML::LibXML::Node,
-either self-constructed, or produced by one of the builder methods in
-this class, like L<enc()|XML::Compile::SOAP11::Encoding/"Encoding"> or L<typed()|XML::Compile::SOAP11::Encoding/"Encoding">.
-
-Returned is the XML::LibXML::Element which represents the
-array.
-
- -Option      --Default
-  array_type    <generated>
-  id            <undef>
-  nested_array  ''
-  offset        0
-  slice         <all remaining>
-
-=over 2
-
-=item array_type => STRING
-
-The arrayType attribute content.  When explicitly set to undef, the
-attribute is not created.
-
-=item id => STRING
-
-Assign an id to the array.  If not defined, than no id attribute is
-added.
-
-=item nested_array => STRING
-
-The ARRAY type should reflect nested array structures if they are
-homogeneous.  This is a really silly part of the specs, because there
-is no need for it on any other comparible place in the specs... but ala.
-
-For instance: C<< nested_array => '[,]' >>, means that this array
-contains two-dimensional arrays.
-
-=item offset => INTEGER
-
-When a partial array is to be transmitted, the number of the base
-element.
-
-=item slice => INTEGER
-
-When a partial array is to be transmitted, this is the length of
-the slice to be sent (the number of elements starting with the C<offset>
-element)
-
-=back
-
-=item $obj-E<gt>B<element>($type, $name, $value)
-
-Create an element.  The $name is for node, where a namespace component
-is translated into a prefix.  When you wish for a C<type> attribute,
-use L<typed()|XML::Compile::SOAP11::Encoding/"Encoding">.
-
-When the $type does not contain a namespace indication, it is taken
-in the selected schema namespace.  If the $value already is a
-XML::LibXML::Element, then that one is used (and the $name ignored).
-
-=item $obj-E<gt>B<enc>( $local, $value, [$id] )
-
-In the SOAP specification, encoding types are defined: elements
-which do not have a distinguishable name but use the type of the
-data as name.  Yep, ugly!
-
-example: 
-
-  my $xml = $soap->enc('int', 43);
-  my $xml = $soap->enc(int => 43);
-  print $xml->toString;
-    # <SOAP-ENC:int>43</SOAP-ENC:int>
-
-  my $xml = $soap->enc('int', 42, id => 'me');
-  my $xml = $soap->enc(int => 42, id => 'me');
-  print $xml->toString;
-    # <SOAP-ENC:int id="me">42</SOAP-ENC:int>
-
-=item $obj-E<gt>B<href>( $name, $element, [$id] )
-
-Create a reference element with $name to the existing $element.  When the
-$element does not have an "id" attribute yet, then $id will be used.  In
-case not $id was specified, then one is generated.
-
-=item $obj-E<gt>B<multidim>( <$name|undef>, $item_type, $elements, %options )
-
-A multi-dimensional array, less flexible than a single dimensional
-array, which can be created with L<array()|XML::Compile::SOAP11::Encoding/"Encoding">.
-
-The table of $elements (ARRAY of ARRAYs) must be full: in each of the
-dimensions, the length of each row must be the same.  On the other
-hand, it may be sparse (contain undefs).  The size of each dimension is
-determined by the length of its first element.
-
- -Option--Default
-  id      undef
-
-=over 2
-
-=item id => STRING
-
-=back
-
-=item $obj-E<gt>B<nil>( [$type], $name )
-
-Create an element with $name which explicitly has the C<xsi:nil> attribute.
-If the $name is full (has a namespace to it), it will be translated into
-a QNAME, otherwise, it is considered not namespace qualified.
-
-If a $type is given, then an explicit type parameter is added.
-
-=item $obj-E<gt>B<prefixed>( $type|<$ns,$local> )
-
-Translate a $ns-$local combination (which may be represented as
-a packed $type) into a prefixed notation.
-
-=item $obj-E<gt>B<startEncoding>(%options)
-
- -Option--Default
-  doc     <created internally with utf8>
-
-=over 2
-
-=item doc => XML::LibXML::Document node
-
-=back
-
-=item $obj-E<gt>B<struct>($type, $childs)
-
-Create a structure, an element with children.  The $childs must be fully
-prepared XML::LibXML::Element objects.
-
-=item $obj-E<gt>B<typed>($type, $name, $value)
-
-A "typed" element shows its type explicitly, via the "xsi:type" attribute.
-The $value will get processed via an auto-generated XML::Compile writer,
-so validated.  The processing is cashed.
-
-When $value already is an XML::LibXML::Element, then no processing
-nor value checking will be performed.  The $name will be ignored.
-
-If the $type is not qualified, then it is interpreted as basic type, as
-defined by the selected schema.  If you explicitly
-need a non-namespace typed item, then use an empty namespace.  In any
-case, the type must be defined and the value is validated.
-
-example: 
-
- my $xml = $soap->typed(int => count => 5);
- my $xml = $soap->typed(pack_type(SCHEMA1999, 'int'), count => 5);
-
- my $xml = $soap->typed(pack_type('', 'mine'), a => 1);
- my $xml = $soap->typed('{}mine'), a => 1); #same
-
-=back
-
-=head3 Decoding
-
-=over 4
-
-=item $obj-E<gt>B<rpcDecode>($xmlnodes)
-
-Decode the elements found in the $xmlnodes (list of XML::LibXML::Node
-objects).  Use Data::Dumper to figure-out what the produced output is:
-it is a guess, so may not be perfect (do not use RPC but document style
-soap for good results).
-
-The decoded data is returned.  When "simplify" is set, then the returned
-data is compact but may be sloppy.  Otherwise, a HASH is returned
-containing as much info as could be extracted from the tree.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP11/Operation.pm b/lib/XML/Compile/SOAP11/Operation.pm
index 6b1b8d8..d0c4bed 100644
--- a/lib/XML/Compile/SOAP11/Operation.pm
+++ b/lib/XML/Compile/SOAP11/Operation.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP11::Operation;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::SOAP::Operation';
 
 use warnings;
@@ -32,6 +25,42 @@ $VERSION ||= '(devel)';
 # can be different.  Class reference is key.
 my (%soap11_client, %soap11_server);
 
+=chapter NAME
+
+XML::Compile::SOAP11::Operation - defines a SOAP11 interaction
+
+=chapter SYNOPSIS
+ # object created by XML::Compile::WSDL*
+ my $op = $wsdl->operation('GetStockPrices');
+ $op->explain($wsdl, PERL => 'INPUT', recurse => 1);
+
+=chapter DESCRIPTION
+Objects of this type define one possible SOAP11 interaction, either
+client side or server side.
+
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+
+C<input_def>, C<output_def> and C<fault_def> are HASHes which contain
+the input and output message header, body and fault-header definitions
+in WSDL1.1 style.
+
+=option  input_def HASH
+=default input_def <undef>
+
+=option  output_def HASH
+=default output_def <undef>
+
+=option  fault_def HASH
+=default fault_def <undef>
+
+=option  style  'document'|'rpc'
+=default style  'document'
+
+=cut
 
 sub init($)
 {   my ($self, $args) = @_;
@@ -181,6 +210,10 @@ sub _fault_parts($$$)
 
 #-------------------------------------------
 
+=section Accessors
+
+=method style 
+=cut
 
 sub style()     {shift->{style}}
 sub version()   { 'SOAP11' }
@@ -189,6 +222,28 @@ sub clientClass { 'XML::Compile::SOAP11::Client' }
 
 #-------------------------------------------
 
+=section Modify
+
+Operations are often modified by SOAP extensions.
+See M<XML::Compile::SOAP::WSA>, for instance. Also demonstrated in
+the FAQ, M<XML::Compile::SOAP::FAQ>.
+
+=method addHeader <'INPUT'|'OUTPUT'|'FAULT'>, $label, $element, %options
+Add a header definitions.  Many protocols on top of SOAP, like WSS, add
+headers to the operations which are not specified in the WSDL.
+
+[2.31] When you add a header with same $label again, it will get silently
+ignored unless the $element type differs. An $element is either a full
+type or a [3.00] prefixed type.
+
+=option  mustUnderstand BOOLEAN
+=default mustUnderstand C<undef>
+[2.33] adds the mustUnderstand attribute.
+
+=option  destination ROLE
+=default destination C<undef>
+[2.33] adds the destination attribute.
+=cut
 
 sub addHeader($$$%)
 {   my ($self, $dir, $label, $el, %opts) = @_;
@@ -223,6 +278,20 @@ sub addHeader($$$%)
 
 #-------------------------------------------
 
+=section Handlers
+
+=method compileHandler %options
+Prepare the routines which will decode the request and encode the answer,
+as will be run on the server. The M<XML::Compile::SOAP::Server> will
+connect these. All %options will get passed to
+M<XML::Compile::SOAP11::Server::compileHandler()>
+
+=requires callback CODE
+
+=option  selector CODE
+=default selector <from input def>
+Determines whether the handler belongs to a received message.
+=cut
 
 sub compileHandler(@)
 {   my ($self, %args) = @_;
@@ -247,6 +316,23 @@ sub compileHandler(@)
     $soap->compileHandler(%args);
 }
 
+=method compileClient %options
+Returns one CODE reference which handles the processing for this
+operation. Options C<transporter>, C<transport_hook>, and
+C<endpoint> are passed to M<compileTransporter()>.
+
+You pass that CODE reference an input message of the correct
+type, as pure Perl HASH structure.  An 'request-response' operation
+will return then answer, or C<undef> in case of failure.  An 'one-way'
+operation with return C<undef> in case of failure, and a true value
+when successful.
+
+You B<cannot> pass options for M<XML::Compile::Schema::compile()>, like
+C<<sloppy_integers => 0>>, hooks or typemaps this way. Provide these to
+the C<::WSDL> or other C<::Cache> object which defines the types, via
+C<new> option C<opts_rw> and friends.
+
+=cut
 
 sub compileClient(@)
 {   my ($self, %args) = @_;
@@ -274,6 +360,29 @@ sub compileClient(@)
 
 #--------------------------
 
+=section Helpers
+
+=method explain $wsdl, $format, $direction, %options
+[since 2.13]
+
+Dump an annotated structure showing how the operation works, helping
+developers to understand the schema. The $format must be string "PERL".
+($format "XML" is not yet supported)
+
+When the $direction is string "INPUT", it will return the message which
+the client sends to the server (input for the server). The "OUTPUT"
+message is sent as response by the server.
+
+All %options besides those described here are passed to
+M<XML::Compile::Schema::template()>, when C<recurse> is enabled.
+
+=option  skip_header BOOLEAN
+=default skip_header <false>
+
+=option  recurse BOOLEAN
+=default recurse <false>
+Append the templates of all the part structures.
+=cut
 
 my $sep = '#--------------------------------------------------------------';
 
diff --git a/lib/XML/Compile/SOAP11/Operation.pod b/lib/XML/Compile/SOAP11/Operation.pod
deleted file mode 100644
index 62f8cd5..0000000
--- a/lib/XML/Compile/SOAP11/Operation.pod
+++ /dev/null
@@ -1,282 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP11::Operation - defines a SOAP11 interaction
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP11::Operation
-   is a XML::Compile::SOAP::Operation
-
-=head1 SYNOPSIS
-
- # object created by XML::Compile::WSDL*
- my $op = $wsdl->operation('GetStockPrices');
- $op->explain($wsdl, PERL => 'INPUT', recurse => 1);
-
-=head1 DESCRIPTION
-
-Objects of this type define one possible SOAP11 interaction, either
-client side or server side.
-
-Extends L<"DESCRIPTION" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"METHODS">.
- 
-=head2 Constructors
-
-Extends L<"Constructors" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"Constructors">.
- 
-=over 4
-
-=item XML::Compile::SOAP11::Operation-E<gt>B<new>(%options)
-
-C<input_def>, C<output_def> and C<fault_def> are HASHes which contain
-the input and output message header, body and fault-header definitions
-in WSDL1.1 style.
-
- -Option     --Defined in                   --Default
-  action       XML::Compile::SOAP::Operation  undef
-  endpoints    XML::Compile::SOAP::Operation  []
-  fault_def                                   <undef>
-  input_def                                   <undef>
-  kind         XML::Compile::SOAP::Operation  <required>
-  name         XML::Compile::SOAP::Operation  <required>
-  output_def                                  <undef>
-  schemas      XML::Compile::SOAP::Operation  <required>
-  server_type  XML::Compile::SOAP::Operation  undef
-  style                                       'document'
-  transport    XML::Compile::SOAP::Operation  'HTTP'
-
-=over 2
-
-=item action => STRING
-
-=item endpoints => ADDRESS|ARRAY
-
-=item fault_def => HASH
-
-=item input_def => HASH
-
-=item kind => 'one-way'|...
-
-=item name => STRING
-
-=item output_def => HASH
-
-=item schemas => XML::Compile::Cache
-
-=item server_type => NAME
-
-=item style => 'document'|'rpc'
-
-=item transport => URI|'HTTP'
-
-=back
-
-=back
-
-=head2 Accessors
-
-Extends L<"Accessors" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"Accessors">.
- 
-=over 4
-
-=item $obj-E<gt>B<bindingName>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<clientClass>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<endPoints>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<kind>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<longName>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<name>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<portName>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<schemas>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<serverClass>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<serviceName>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<soapAction>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<style>()
-
-=item $obj-E<gt>B<version>()
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=item $obj-E<gt>B<wsaAction>('INPUT'|'OUTPUT')
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Accessors">
-
-=back
-
-=head2 Modify
-
-Operations are often modified by SOAP extensions.
-See L<XML::Compile::SOAP::WSA|XML::Compile::SOAP::WSA>, for instance. Also demonstrated in
-the FAQ, L<XML::Compile::SOAP::FAQ|XML::Compile::SOAP::FAQ>.
-
-=over 4
-
-=item $obj-E<gt>B<addHeader>( <'INPUT'|'OUTPUT'|'FAULT'>, $label, $element, %options )
-
-Add a header definitions.  Many protocols on top of SOAP, like WSS, add
-headers to the operations which are not specified in the WSDL.
-
-[2.31] When you add a header with same $label again, it will get silently
-ignored unless the $element type differs. An $element is either a full
-type or a [3.00] prefixed type.
-
- -Option        --Default
-  destination     undef
-  mustUnderstand  undef
-
-=over 2
-
-=item destination => ROLE
-
-[2.33] adds the destination attribute.
-
-=item mustUnderstand => BOOLEAN
-
-[2.33] adds the mustUnderstand attribute.
-
-=back
-
-=back
-
-=head2 Handlers
-
-Extends L<"Handlers" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"Handlers">.
- 
-=over 4
-
-=item $obj-E<gt>B<compileClient>(%options)
-
-Returns one CODE reference which handles the processing for this
-operation. Options C<transporter>, C<transport_hook>, and
-C<endpoint> are passed to L<compileTransporter()|XML::Compile::SOAP::Operation/"Handlers">.
-
-You pass that CODE reference an input message of the correct
-type, as pure Perl HASH structure.  An 'request-response' operation
-will return then answer, or C<undef> in case of failure.  An 'one-way'
-operation with return C<undef> in case of failure, and a true value
-when successful.
-
-You B<cannot> pass options for L<XML::Compile::Schema::compile()|XML::Compile::Schema/"Compilers">, like
-C<<sloppy_integers => 0>>, hooks or typemaps this way. Provide these to
-the C<::WSDL> or other C<::Cache> object which defines the types, via
-C<new> option C<opts_rw> and friends.
-
-=item $obj-E<gt>B<compileHandler>(%options)
-
-Prepare the routines which will decode the request and encode the answer,
-as will be run on the server. The L<XML::Compile::SOAP::Server|XML::Compile::SOAP::Server> will
-connect these. All %options will get passed to
-L<XML::Compile::SOAP11::Server::compileHandler()|XML::Compile::SOAP::Server/"Actions">
-
- -Option  --Default
-  callback  <required>
-  selector  <from input def>
-
-=over 2
-
-=item callback => CODE
-
-=item selector => CODE
-
-Determines whether the handler belongs to a received message.
-
-=back
-
-=item $obj-E<gt>B<compileTransporter>(%options)
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Handlers">
-
-=back
-
-=head2 Helpers
-
-Extends L<"Helpers" in XML::Compile::SOAP::Operation|XML::Compile::SOAP::Operation/"Helpers">.
- 
-=over 4
-
-=item $obj-E<gt>B<explain>($wsdl, $format, $direction, %options)
-
-[since 2.13]
-
-Dump an annotated structure showing how the operation works, helping
-developers to understand the schema. The $format must be string "PERL".
-($format "XML" is not yet supported)
-
-When the $direction is string "INPUT", it will return the message which
-the client sends to the server (input for the server). The "OUTPUT"
-message is sent as response by the server.
-
-All %options besides those described here are passed to
-L<XML::Compile::Schema::template()|XML::Compile::Schema/"Compilers">, when C<recurse> is enabled.
-
- -Option     --Default
-  recurse      <false>
-  skip_header  <false>
-
-=over 2
-
-=item recurse => BOOLEAN
-
-Append the templates of all the part structures.
-
-=item skip_header => BOOLEAN
-
-=back
-
-=item $obj-E<gt>B<parsedWSDL>(%options)
-
-Inherited, see L<XML::Compile::SOAP::Operation/"Helpers">
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/SOAP11/Server.pm b/lib/XML/Compile/SOAP11/Server.pm
index 1bfeefd..1d2a426 100644
--- a/lib/XML/Compile/SOAP11/Server.pm
+++ b/lib/XML/Compile/SOAP11/Server.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::SOAP11::Server;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::SOAP11', 'XML::Compile::SOAP::Server';
 
 use warnings;
@@ -20,6 +13,18 @@ use Log::Report    'xml-compile-soap';
 use XML::Compile::SOAP::Util qw/SOAP11ENV SOAP11NEXT/;
 use XML::Compile::Util  qw/pack_type unpack_type SCHEMA2001/;
 
+=chapter NAME
+XML::Compile::SOAP11::Server - SOAP1.1 server needs
+
+=chapter SYNOPSIS
+
+=chapter DESCRIPTION
+This module does not implement an actual soap server, but the
+needs to create the server side.  The server daemon is implemented
+by M<XML::Compile::SOAP::Daemon>
+
+=chapter METHODS
+=cut
 
 sub init($)
 {   my ($self, $args) = @_;
diff --git a/lib/XML/Compile/SOAP11/Server.pod b/lib/XML/Compile/SOAP11/Server.pod
deleted file mode 100644
index aa59102..0000000
--- a/lib/XML/Compile/SOAP11/Server.pod
+++ /dev/null
@@ -1,50 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::SOAP11::Server - SOAP1.1 server needs
-
-=head1 INHERITANCE
-
- XML::Compile::SOAP11::Server
-   is a XML::Compile::SOAP11
-   is a XML::Compile::SOAP
-
- XML::Compile::SOAP11::Server
-   is a XML::Compile::SOAP::Server
-
-=head1 SYNOPSIS
-
-=head1 DESCRIPTION
-
-This module does not implement an actual soap server, but the
-needs to create the server side.  The server daemon is implemented
-by L<XML::Compile::SOAP::Daemon|XML::Compile::SOAP::Daemon>
-
-Extends L<"DESCRIPTION" in XML::Compile::SOAP::Server|XML::Compile::SOAP::Server/"DESCRIPTION">.
- 
-Extends L<"DESCRIPTION" in XML::Compile::SOAP11|XML::Compile::SOAP11/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::SOAP::Server|XML::Compile::SOAP::Server/"METHODS">.
- 
-Extends L<"METHODS" in XML::Compile::SOAP11|XML::Compile::SOAP11/"METHODS">.
- 
-=head1 DETAILS
-
-Extends L<"DETAILS" in XML::Compile::SOAP11|XML::Compile::SOAP11/"DETAILS">.
- 
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/Transport.pm b/lib/XML/Compile/Transport.pm
index 84a4478..113fa60 100644
--- a/lib/XML/Compile/Transport.pm
+++ b/lib/XML/Compile/Transport.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::Transport;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::SOAP::Extension';
 
 use warnings;
@@ -22,6 +15,57 @@ use Log::Report::Exception ();
 use XML::LibXML     ();
 use Time::HiRes     qw/time/;
 
+=chapter NAME
+XML::Compile::Transport - base class for XML transporters
+
+=chapter SYNOPSIS
+ use XML::Compile::Transport::SOAPHTTP;
+ my $trans  = XML::Compile::Transport::SOAPHTTP->new(...);
+ my $call   = $trans->compileClient(...);
+
+ my ($xmlout, $trace) = $call->($xmlin);
+ my $xmlout = $call->($xmlin);   # when no trace needed
+
+=chapter DESCRIPTION
+This module defines the exchange of (XML) messages. The module does not
+known how to parse or compose XML, but only worries about the transport
+aspects.
+
+On the moment, there are three transporter implementations:
+
+=over 4
+
+=item M<XML::Compile::Transport::SOAPHTTP>
+implements an synchronous message exchange; the library waits for an
+answer before it returns to the user application. The information is
+exchanged using HTTP with SOAP encapsulation (SOAP also defines a
+transport protocol over HTTP without encapsulation)
+
+=item M<XML::Compile::Transport::SOAPHTTP_AnyEvent>
+Event-driven implementation, based on AnyEvent.  The user provides a
+callback to handle responses. Many queries can be spawned in parallel,
+in a single process.  Find this in a separate distribution.
+
+=item M<XML::Compile::Transport::SOAPHTTP_MojoUA>
+Event-driven implementation,  which fits in the Mojolicious infrastructure.
+Find this in a separate distribution.
+
+=back
+
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+
+=option  charset STRING
+=default charset 'UTF-8'
+
+=option  address URI|ARRAY-of-URI
+=default address 'http://localhost'
+One or more URI which represents the servers.
+
+=cut
 
 sub init($)
 {   my ($self, $args) = @_;
@@ -37,12 +81,24 @@ sub init($)
 
 #-------------------------------------
 
+=section Accessors
+
+=method charset 
+Returns the charset to be used when sending,
+=cut
 
 sub charset() {shift->{charset}}
 
+=method addresses 
+Returns a list of all server contact addresses (URIs)
+=cut
 
 sub addresses() { @{shift->{addrs}} }
 
+=method address 
+Get a server address to contact. If multiple addresses were specified,
+than one is chosen at random.
+=cut
 
 sub address()
 {   my $addrs = shift->{addrs};
@@ -51,6 +107,37 @@ sub address()
 
 #-------------------------------------
 
+=section Handlers
+
+=method compileClient %options
+Compile a client handler.  Returned is a subroutine which is called
+with a text represenation of the XML request, or an XML::LibXML tree.
+In SCALAR context, an XML::LibXML parsed tree of the answer message
+is returned.  In LIST context, that answer is followed by a HASH which
+contains trace information.
+
+=option  hook CODE
+=default hook <undef>
+See section L</Use of the transport hook>.
+When defined, the hook will be called, in stead of transmitting the
+message.  The hook will gets three parameters passed in: the textual
+representation of the XML message to be transmitted, the trace HASH with
+all values collected so far, and the transporter object.  The trace HASH
+will have a massive amount of additional information added as well.
+
+You may add information to the trace.  You have to return a textual
+representation of the XML answer, or C<undef> to indicate that the
+message was totally unacceptable.
+
+=option  kind STRING
+=default kind 'request-response'
+Kind of communication, as defined by WSDL.
+
+=option  xml_format 0|1|2
+=default xml_format 0
+[2.26] See M<XML::LibXML::Document::toString()>.  With '1', you will get
+beautified output.
+=cut
 
 sub compileClient(@)
 {   my ($self, %args) = @_;
@@ -114,6 +201,11 @@ sub _prepare_call($) { panic "not implemented" }
 
 #--------------------------------------
 
+=chapter Helpers
+
+=c_method register $uri
+Declare an transporter type.
+=cut
 
 {   my %registered;
     sub register($)   { my ($class, $uri) = @_; $registered{$uri} = $class }
@@ -123,5 +215,145 @@ sub _prepare_call($) { panic "not implemented" }
 
 #--------------------------------------
 
+=chapter DETAILS
+
+=section Use of the transport hook
+
+A I<transport hook> can be used to follow the process of creating a
+message to its furthest extend: it will be called with the data as
+used by the actual protocol, but will not connect to the internet.
+Within the transport hook routine, you have to simulate the remote
+server's activities.
+
+There are two reasons to use a hook:
+
+=over 4
+
+=item .
+You want to fake a server, to produce a test environment.
+
+=item .
+You may need to modify the request or answer messages outside the
+reach of M<XML::Compile::SOAP>, because something is wrong in either
+your WSDL of M<XML::Compile> message processing.
+
+=back
+
+=subsection XML and Header Modifications
+  
+Some servers require special extensions, which do not follow any standard
+(or logic). But even those features can be tricked, although it requires
+quite some programming skills.
+
+The C<transport_hook> routine is called with a C<$trace> hash, one of
+whose entries is the UserAgent which was set up for the data transfer. You
+can modify the outgoing message XML body and headers, carry out the data
+exchange using the UserAgent, and then examine the returned Response for
+content and headers using methods similar to the following:
+
+ sub transport_hook($$$)
+ {   my ($request, $trace, $transporter) = @_;
+     my $content = $request->content;
+
+     # ... modify content if you need
+     my $new_content = encode "UTF-8", $anything;
+     $request->content($new_content);
+     $request->header(Content_Length => length $new_content);
+     $request->header(Content_Type => 'text/plain; charset=UTF-8');
+
+     # ... update the headers
+     $request->header(Name => "value");
+
+     # sent the request myself
+     my $ua = $trace->{user_agent};
+     my $response = $ua->request($request);
+
+     # ... check the response headers
+     my $name = $response->header('Name');
+
+     # ... use the response content
+     my $received = $response->decoded_content || $response->content;
+
+     $response;
+ }
+
+You should be aware that if you change the size or length of the content
+you MUST update the C<Content-Length> header value, as demonstrated above.
+
+=subsection Transport hook for debugging
+
+The transport hook is a perfect means for producing automated tests.  Also,
+the XML::Compile::SOAP module tests use it extensively.  It works like this
+(for the SOAPHTTP simluation):
+
+ use Test::More;
+
+ sub fake_server($$)
+ {  my ($request, $trace) = @_;
+    my $content = $request->decoded_content;
+    is($content, <<__EXPECTED_CONTENT);
+<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
+__EXPECTED_CONTENT
+
+    HTTP::Response->new(200, 'Constant'
+      , [ 'Content-Type' => 'text/xml' ]
+      , <<__ANSWER
+<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
+__ANSWER
+ }
+ 
+Then, the fake server is initiated in one of the follow ways:
+
+  my $transport = XML::Compile::Transport::SOAPHTTP->new(...);
+  my $http = $transport->compileClient(hook => \&fake_server, ...);
+  $wsdl->compileClient('GetLastTracePrice', transporter => $http);
+
+or
+
+  my $soap = XML::Compile::SOAP11::Client->new(...);
+  my $call = $soap->compileClient(encode => ..., decode => ...,
+      transport_hook => \&fake_server);
+
+or
+
+  my $wsdl = XML::Compile::WSDL11->new(...);
+  $wsdl->compileClient('GetLastTracePrice',
+      transport_hook => \&fake_server);
+
+
+=subsection Transport hook for basic authentication
+
+[Adapted from an example contributed by Kieron Johnson]
+This example shows a transport_hook for compileClient() to add to http
+headers for the basic http authentication.  The parameter can also be
+used for compileAll() and many other related functions.
+
+  my $call = $wsdl->compileClient($operation
+     , transport_hook => \&basic_auth );
+
+  # HTTP basic authentication encodes the username and password with
+  # Base64. The encoded source string has format: "username:password"
+  # With the below HTTP header being required:
+  #        "Authorization: Basic [encoded password]"
+
+  use MIME::Base64 'encode_base64';
+
+  my $user     = 'myuserid' ;
+  my $password = 'mypassword';
+
+  sub basic_auth($$)
+  {   my ($request, $trace) = @_;
+
+      # Encode userid and password
+      my $authorization = 'Basic '. encode_base64 "$user:$password";
+
+      # Modify http header to include basic authorisation
+      $request->header(Authorization => $authorization );
+
+      my $ua = $trace->{user_agent};
+      $ua->request($request);
+  }
+
+=cut
 
 1;
diff --git a/lib/XML/Compile/Transport.pod b/lib/XML/Compile/Transport.pod
deleted file mode 100644
index 483b0d8..0000000
--- a/lib/XML/Compile/Transport.pod
+++ /dev/null
@@ -1,369 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::Transport - base class for XML transporters
-
-=head1 INHERITANCE
-
- XML::Compile::Transport
-   is a XML::Compile::SOAP::Extension
-
- XML::Compile::Transport is extended by
-   XML::Compile::Transport::SOAPHTTP
-   XML::Compile::Transport::SOAPHTTP_AnyEvent
-
-=head1 SYNOPSIS
-
- use XML::Compile::Transport::SOAPHTTP;
- my $trans  = XML::Compile::Transport::SOAPHTTP->new(...);
- my $call   = $trans->compileClient(...);
-
- my ($xmlout, $trace) = $call->($xmlin);
- my $xmlout = $call->($xmlin);   # when no trace needed
-
-=head1 DESCRIPTION
-
-This module defines the exchange of (XML) messages. The module does not
-known how to parse or compose XML, but only worries about the transport
-aspects.
-
-On the moment, there are three transporter implementations:
-
-=over 4
-
-=item L<XML::Compile::Transport::SOAPHTTP|XML::Compile::Transport::SOAPHTTP>
-
-implements an synchronous message exchange; the library waits for an
-answer before it returns to the user application. The information is
-exchanged using HTTP with SOAP encapsulation (SOAP also defines a
-transport protocol over HTTP without encapsulation)
-
-=item L<XML::Compile::Transport::SOAPHTTP_AnyEvent|XML::Compile::Transport::SOAPHTTP_AnyEvent>
-
-Event-driven implementation, based on AnyEvent.  The user provides a
-callback to handle responses. Many queries can be spawned in parallel,
-in a single process.  Find this in a separate distribution.
-
-=item XML::Compile::Transport::SOAPHTTP_MojoUA
-
-Event-driven implementation,  which fits in the Mojolicious infrastructure.
-Find this in a separate distribution.
-
-=back
-
-Extends L<"DESCRIPTION" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"METHODS">.
- 
-=head2 Constructors
-
-Extends L<"Constructors" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"Constructors">.
- 
-=over 4
-
-=item XML::Compile::Transport-E<gt>B<new>(%options)
-
- -Option --Default
-  address  'http://localhost'
-  charset  'UTF-8'
-
-=over 2
-
-=item address => URI|ARRAY-of-URI
-
-One or more URI which represents the servers.
-
-=item charset => STRING
-
-=back
-
-=back
-
-=head2 WSDL11
-
-Extends L<"WSDL11" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"WSDL11">.
- 
-=over 4
-
-=item $obj-E<gt>B<wsdl11Init>($wsdl, $args)
-
-=item XML::Compile::Transport-E<gt>B<wsdl11Init>($wsdl, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"WSDL11">
-
-=back
-
-=head2 SOAP11
-
-Extends L<"SOAP11" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"SOAP11">.
- 
-=over 4
-
-=item $obj-E<gt>B<soap11ClientWrapper>($operation, $call, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=item $obj-E<gt>B<soap11HandlerWrapper>($operation, $callback, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=item $obj-E<gt>B<soap11OperationInit>($operation, $args)
-
-=item XML::Compile::Transport-E<gt>B<soap11OperationInit>($operation, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=back
-
-=head2 SOAP12
-
-Extends L<"SOAP12" in XML::Compile::SOAP::Extension|XML::Compile::SOAP::Extension/"SOAP12">.
- 
-=over 4
-
-=item $obj-E<gt>B<soap12ClientWrapper>($operation, $call, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=item $obj-E<gt>B<soap12HandlerWrapper>($operation, $callback, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=item $obj-E<gt>B<soap12OperationInit>($operation, $args)
-
-=item XML::Compile::Transport-E<gt>B<soap12OperationInit>($operation, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<address>()
-
-Get a server address to contact. If multiple addresses were specified,
-than one is chosen at random.
-
-=item $obj-E<gt>B<addresses>()
-
-Returns a list of all server contact addresses (URIs)
-
-=item $obj-E<gt>B<charset>()
-
-Returns the charset to be used when sending,
-
-=back
-
-=head2 Handlers
-
-=over 4
-
-=item $obj-E<gt>B<compileClient>(%options)
-
-Compile a client handler.  Returned is a subroutine which is called
-with a text represenation of the XML request, or an XML::LibXML tree.
-In SCALAR context, an XML::LibXML parsed tree of the answer message
-is returned.  In LIST context, that answer is followed by a HASH which
-contains trace information.
-
- -Option    --Default
-  hook        <undef>
-  kind        'request-response'
-  xml_format  0
-
-=over 2
-
-=item hook => CODE
-
-See section L</Use of the transport hook>.
-When defined, the hook will be called, in stead of transmitting the
-message.  The hook will gets three parameters passed in: the textual
-representation of the XML message to be transmitted, the trace HASH with
-all values collected so far, and the transporter object.  The trace HASH
-will have a massive amount of additional information added as well.
-
-You may add information to the trace.  You have to return a textual
-representation of the XML answer, or C<undef> to indicate that the
-message was totally unacceptable.
-
-=item kind => STRING
-
-Kind of communication, as defined by WSDL.
-
-=item xml_format => 0|1|2
-
-[2.26] See XML::LibXML::Document subroutine toString.  With '1', you will get
-beautified output.
-
-=back
-
-=back
-
-=head1 DETAILS
-
-=head2 Use of the transport hook
-
-A I<transport hook> can be used to follow the process of creating a
-message to its furthest extend: it will be called with the data as
-used by the actual protocol, but will not connect to the internet.
-Within the transport hook routine, you have to simulate the remote
-server's activities.
-
-There are two reasons to use a hook:
-
-=over 4
-
-=item .
-
-You want to fake a server, to produce a test environment.
-
-=item .
-
-You may need to modify the request or answer messages outside the
-reach of L<XML::Compile::SOAP|XML::Compile::SOAP>, because something is wrong in either
-your WSDL of L<XML::Compile|XML::Compile> message processing.
-
-=back
-
-=head3 XML and Header Modifications
-
-Some servers require special extensions, which do not follow any standard
-(or logic). But even those features can be tricked, although it requires
-quite some programming skills.
-
-The C<transport_hook> routine is called with a C<$trace> hash, one of
-whose entries is the UserAgent which was set up for the data transfer. You
-can modify the outgoing message XML body and headers, carry out the data
-exchange using the UserAgent, and then examine the returned Response for
-content and headers using methods similar to the following:
-
- sub transport_hook($$$)
- {   my ($request, $trace, $transporter) = @_;
-     my $content = $request->content;
-
-     # ... modify content if you need
-     my $new_content = encode "UTF-8", $anything;
-     $request->content($new_content);
-     $request->header(Content_Length => length $new_content);
-     $request->header(Content_Type => 'text/plain; charset=UTF-8');
-
-     # ... update the headers
-     $request->header(Name => "value");
-
-     # sent the request myself
-     my $ua = $trace->{user_agent};
-     my $response = $ua->request($request);
-
-     # ... check the response headers
-     my $name = $response->header('Name');
-
-     # ... use the response content
-     my $received = $response->decoded_content || $response->content;
-
-     $response;
- }
-
-You should be aware that if you change the size or length of the content
-you MUST update the C<Content-Length> header value, as demonstrated above.
-
-=head3 Transport hook for debugging
-
-The transport hook is a perfect means for producing automated tests.  Also,
-the XML::Compile::SOAP module tests use it extensively.  It works like this
-(for the SOAPHTTP simluation):
-
- use Test::More;
-
- sub fake_server($$)
- {  my ($request, $trace) = @_;
-    my $content = $request->decoded_content;
-    is($content, <<__EXPECTED_CONTENT);
-<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
-__EXPECTED_CONTENT
-
-    HTTP::Response->new(200, 'Constant'
-      , [ 'Content-Type' => 'text/xml' ]
-      , <<__ANSWER
-<SOAP-ENV:Envelope>...</SOAP-ENV:Envelope>
-__ANSWER
- }
- 
-Then, the fake server is initiated in one of the follow ways:
-
-  my $transport = XML::Compile::Transport::SOAPHTTP->new(...);
-  my $http = $transport->compileClient(hook => \&fake_server, ...);
-  $wsdl->compileClient('GetLastTracePrice', transporter => $http);
-
-or
-
-  my $soap = XML::Compile::SOAP11::Client->new(...);
-  my $call = $soap->compileClient(encode => ..., decode => ...,
-      transport_hook => \&fake_server);
-
-or
-
-  my $wsdl = XML::Compile::WSDL11->new(...);
-  $wsdl->compileClient('GetLastTracePrice',
-      transport_hook => \&fake_server);
-
-=head3 Transport hook for basic authentication
-
-[Adapted from an example contributed by Kieron Johnson]
-This example shows a transport_hook for compileClient() to add to http
-headers for the basic http authentication.  The parameter can also be
-used for compileAll() and many other related functions.
-
-  my $call = $wsdl->compileClient($operation
-     , transport_hook => \&basic_auth );
-
-  # HTTP basic authentication encodes the username and password with
-  # Base64. The encoded source string has format: "username:password"
-  # With the below HTTP header being required:
-  #        "Authorization: Basic [encoded password]"
-
-  use MIME::Base64 'encode_base64';
-
-  my $user     = 'myuserid' ;
-  my $password = 'mypassword';
-
-  sub basic_auth($$)
-  {   my ($request, $trace) = @_;
-
-      # Encode userid and password
-      my $authorization = 'Basic '. encode_base64 "$user:$password";
-
-      # Modify http header to include basic authorisation
-      $request->header(Authorization => $authorization );
-
-      my $ua = $trace->{user_agent};
-      $ua->request($request);
-  }
-
-=head1 Helpers
-
-=over 4
-
-=item XML::Compile::Transport-E<gt>B<register>($uri)
-
-Declare an transporter type.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/Transport/SOAPHTTP.pm b/lib/XML/Compile/Transport/SOAPHTTP.pm
index dc0466d..f10d101 100644
--- a/lib/XML/Compile/Transport/SOAPHTTP.pm
+++ b/lib/XML/Compile/Transport/SOAPHTTP.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::Transport::SOAPHTTP;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'XML::Compile::Transport';
 
 use warnings;
@@ -33,6 +26,60 @@ my $mime_xop    = 'application/xop+xml';
 
 __PACKAGE__->register(SOAP11HTTP);
 
+=chapter NAME
+XML::Compile::Transport::SOAPHTTP - exchange XML-SOAP via HTTP
+
+=chapter SYNOPSIS
+ use XML::Compile::Transport::SOAPHTTP;
+
+ my $http = XML::Compile::Transport::SOAPHTTP->new(@options);
+ my $send = $http->compileClient(@options2);
+
+ my $call = $wsdl->compileClient
+   ( operation => 'some-port-name'
+   , transport => $send
+   );
+
+ my ($xmlout, $trace) = $call->($xmlin);
+
+ $wsdl->compileCalls(transport => $send);
+
+=chapter DESCRIPTION
+This module handles the exchange of (XML) messages, according to the
+rules of SOAP (any version).  The module does not known how to parse
+or compose XML, but only worries about the HTTP aspects.
+
+=chapter METHODS
+
+=c_method new %options
+Create a SOAP-over-HTTP handler, implemented as a wrapper around
+M<LWP::UserAgent>.
+
+If you need to change UserAgent settings (for instance at runtime),
+you can always directly access the internal C<LWP::UserAgent> object
+via M<userAgent()>.
+
+B<Warning:> The C<keep_alive> and C<timeout> options are only used when
+an default internal C<LWP::UserAgent> is created; this is only once in a
+program.  Later instantiations of this ::SOAPHTTP will share that default
+agent, even though these passed parameters have different parameters.
+If that is not what you want, then pass your own C<user_agent> object to
+the constructor to avoid the use of the default.
+
+=option  user_agent LWP::UserAgent object
+=default user_agent <created when needed>
+If you do not pass your own user agent, a default will be created for you.
+
+=option  keep_alive BOOLEAN
+=default keep_alive <true>
+When connection can be re-used.
+
+=option  timeout SECONDS
+=default timeout 180
+The maximum time for a single connection before the client will close it.
+The server may close it earlier.  Do not set the timeout too long, because
+you want objects to be cleaned-up.
+=cut
 
 sub init($)
 {   my ($self, $args) = @_;
@@ -53,6 +100,16 @@ sub initWSDL11($)
 
 #-------------------------------------------
 
+=section Accessors
+
+=method userAgent [$agent|<undef, %options>]
+Returns the User Agent which will be used.  You may change the
+configuration of the $agent (the returned M<LWP::UserAgent> object)
+or provide one yourself.  See also M<new(user_agent)>.
+
+Changes to the agent configuration can be made before or after the
+compilation, or even inbetween SOAP calls.
+=cut
 
 my $default_ua;
 sub userAgent(;$)
@@ -68,11 +125,75 @@ sub userAgent(;$)
       );
 }
 
+=ci_method defaultUserAgent
+[3.07] Returns the used M<LWP::UserAgent>, available after the compilation
+of the SOAP call(s).
+=cut
 
 sub defaultUserAgent() { $default_ua }
 
 #-------------------------------------------
 
+=section Handlers
+
+=method compileClient %options
+
+Compile an HTTP client handler.  Returned is a subroutine which is called
+with a text represenation of the XML request, or an XML::LibXML tree.
+In SCALAR context, an XML::LibXML parsed tree of the answer message
+is returned.  In LIST context, that answer is followed by a HASH which
+contains trace information.
+
+=option  method 'POST'|'M-POST'
+=default method 'POST'
+With C<POST>, you get the standard HTTP exchange.  The C<M-POST> is
+implements the (Microsoft) HTTP Extension Framework.  Some servers
+accept both, other require a specific request.
+
+=option  mpost_id INTEGER
+=default mpost_id 42
+With method C<M-POST>, the header extension fields require (any) number
+to be grouped.
+
+=option  mime_type STRING
+=default mime_type <depends on soap version>
+
+=option  action URI
+=default action ''
+
+=option  soap 'SOAP11'|'SOAP12'|OBJECT
+=default soap 'SOAP11'
+
+=option  header  HTTP::Headers object
+=default header  <created>
+Versions of M<XML::Compile>, M<XML::Compile::SOAP>, and M<LWP> will be
+added to simplify bug reports.
+
+=option  kind    DIRECTION
+=default kind    'request-response'
+What kind of interactie, based on the four types defined by WSDL(1):
+C<notification-operation> (server initiated, no answer required),
+C<one-way> (client initiated, no answer required), C<request-response>
+(client initiated, the usual in both directions), C<solicit-response> (server
+initiated "challenge").
+
+=example create a client
+ my $trans = XML::Compile::Transport::SOAPHTTP->new
+   ( address => 'http://www.stockquoteserver.com/StockQuote'
+   );
+
+ my $call = $trans->compileClient
+   ( action  => 'http://example.com/GetLastTradePrice'
+   );
+
+ # $request and $answer are XML::LibXML trees!
+ # see M<XML::Compile::SOAP::Client::compileClient()> for wrapper which
+ # converts from and to Perl data structures.
+
+ my ($answer, $trace) = $call->($request);
+ my $answer = $call->($request); # drop $trace info immediately
+
+=cut
 
 # SUPER::compileClient() calls this method to do the real work
 sub _prepare_call($)
@@ -333,6 +454,11 @@ sub _prepare_for_no_answer($)
       };
 }
 
+=ci_method headerAddVersions $header
+Adds some lines about module versions, which may help debugging
+or error reports.  This is called when a new client or server
+is being created.
+=cut
 
 sub headerAddVersions($)
 {   my ($thing, $h) = @_;
diff --git a/lib/XML/Compile/Transport/SOAPHTTP.pod b/lib/XML/Compile/Transport/SOAPHTTP.pod
deleted file mode 100644
index 70b5b4f..0000000
--- a/lib/XML/Compile/Transport/SOAPHTTP.pod
+++ /dev/null
@@ -1,306 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::Transport::SOAPHTTP - exchange XML-SOAP via HTTP
-
-=head1 INHERITANCE
-
- XML::Compile::Transport::SOAPHTTP
-   is a XML::Compile::Transport
-   is a XML::Compile::SOAP::Extension
-
-=head1 SYNOPSIS
-
- use XML::Compile::Transport::SOAPHTTP;
-
- my $http = XML::Compile::Transport::SOAPHTTP->new(@options);
- my $send = $http->compileClient(@options2);
-
- my $call = $wsdl->compileClient
-   ( operation => 'some-port-name'
-   , transport => $send
-   );
-
- my ($xmlout, $trace) = $call->($xmlin);
-
- $wsdl->compileCalls(transport => $send);
-
-=head1 DESCRIPTION
-
-This module handles the exchange of (XML) messages, according to the
-rules of SOAP (any version).  The module does not known how to parse
-or compose XML, but only worries about the HTTP aspects.
-
-Extends L<"DESCRIPTION" in XML::Compile::Transport|XML::Compile::Transport/"DESCRIPTION">.
- 
-=head1 METHODS
-
-Extends L<"METHODS" in XML::Compile::Transport|XML::Compile::Transport/"METHODS">.
- 
-=head2 Constructors
-
-Extends L<"Constructors" in XML::Compile::Transport|XML::Compile::Transport/"Constructors">.
- 
-=over 4
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<new>(%options)
-
-Create a SOAP-over-HTTP handler, implemented as a wrapper around
-LWP::UserAgent.
-
-If you need to change UserAgent settings (for instance at runtime),
-you can always directly access the internal C<LWP::UserAgent> object
-via L<userAgent()|XML::Compile::Transport::SOAPHTTP/"Accessors">.
-
-B<Warning:> The C<keep_alive> and C<timeout> options are only used when
-an default internal C<LWP::UserAgent> is created; this is only once in a
-program.  Later instantiations of this ::SOAPHTTP will share that default
-agent, even though these passed parameters have different parameters.
-If that is not what you want, then pass your own C<user_agent> object to
-the constructor to avoid the use of the default.
-
- -Option    --Defined in             --Default
-  address     XML::Compile::Transport  'http://localhost'
-  charset     XML::Compile::Transport  'UTF-8'
-  keep_alive                           <true>
-  timeout                              180
-  user_agent                           <created when needed>
-
-=over 2
-
-=item address => URI|ARRAY-of-URI
-
-=item charset => STRING
-
-=item keep_alive => BOOLEAN
-
-When connection can be re-used.
-
-=item timeout => SECONDS
-
-The maximum time for a single connection before the client will close it.
-The server may close it earlier.  Do not set the timeout too long, because
-you want objects to be cleaned-up.
-
-=item user_agent => LWP::UserAgent object
-
-If you do not pass your own user agent, a default will be created for you.
-
-=back
-
-=back
-
-=head2 WSDL11
-
-Extends L<"WSDL11" in XML::Compile::Transport|XML::Compile::Transport/"WSDL11">.
- 
-=over 4
-
-=item $obj-E<gt>B<wsdl11Init>($wsdl, $args)
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<wsdl11Init>($wsdl, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"WSDL11">
-
-=back
-
-=head2 SOAP11
-
-Extends L<"SOAP11" in XML::Compile::Transport|XML::Compile::Transport/"SOAP11">.
- 
-=over 4
-
-=item $obj-E<gt>B<soap11ClientWrapper>($operation, $call, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=item $obj-E<gt>B<soap11HandlerWrapper>($operation, $callback, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=item $obj-E<gt>B<soap11OperationInit>($operation, $args)
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<soap11OperationInit>($operation, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP11">
-
-=back
-
-=head2 SOAP12
-
-Extends L<"SOAP12" in XML::Compile::Transport|XML::Compile::Transport/"SOAP12">.
- 
-=over 4
-
-=item $obj-E<gt>B<soap12ClientWrapper>($operation, $call, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=item $obj-E<gt>B<soap12HandlerWrapper>($operation, $callback, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=item $obj-E<gt>B<soap12OperationInit>($operation, $args)
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<soap12OperationInit>($operation, $args)
-
-Inherited, see L<XML::Compile::SOAP::Extension/"SOAP12">
-
-=back
-
-=head2 Accessors
-
-Extends L<"Accessors" in XML::Compile::Transport|XML::Compile::Transport/"Accessors">.
- 
-=over 4
-
-=item $obj-E<gt>B<address>()
-
-Inherited, see L<XML::Compile::Transport/"Accessors">
-
-=item $obj-E<gt>B<addresses>()
-
-Inherited, see L<XML::Compile::Transport/"Accessors">
-
-=item $obj-E<gt>B<charset>()
-
-Inherited, see L<XML::Compile::Transport/"Accessors">
-
-=item $obj-E<gt>B<defaultUserAgent>()
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<defaultUserAgent>()
-
-[3.07] Returns the used LWP::UserAgent, available after the compilation
-of the SOAP call(s).
-
-=item $obj-E<gt>B<userAgent>( [$agent|<undef, %options>] )
-
-Returns the User Agent which will be used.  You may change the
-configuration of the $agent (the returned LWP::UserAgent object)
-or provide one yourself.  See also L<new(user_agent)|XML::Compile::Transport::SOAPHTTP/"METHODS">.
-
-Changes to the agent configuration can be made before or after the
-compilation, or even inbetween SOAP calls.
-
-=back
-
-=head2 Handlers
-
-Extends L<"Handlers" in XML::Compile::Transport|XML::Compile::Transport/"Handlers">.
- 
-=over 4
-
-=item $obj-E<gt>B<compileClient>(%options)
-
-Compile an HTTP client handler.  Returned is a subroutine which is called
-with a text represenation of the XML request, or an XML::LibXML tree.
-In SCALAR context, an XML::LibXML parsed tree of the answer message
-is returned.  In LIST context, that answer is followed by a HASH which
-contains trace information.
-
- -Option    --Defined in             --Default
-  action                               ''
-  header                               <created>
-  hook        XML::Compile::Transport  <undef>
-  kind                                 'request-response'
-  method                               'POST'
-  mime_type                            <depends on soap version>
-  mpost_id                             42
-  soap                                 'SOAP11'
-  xml_format  XML::Compile::Transport  0
-
-=over 2
-
-=item action => URI
-
-=item header => HTTP::Headers object
-
-Versions of L<XML::Compile|XML::Compile>, L<XML::Compile::SOAP|XML::Compile::SOAP>, and LWP will be
-added to simplify bug reports.
-
-=item hook => CODE
-
-=item kind => DIRECTION
-
-What kind of interactie, based on the four types defined by WSDL(1):
-C<notification-operation> (server initiated, no answer required),
-C<one-way> (client initiated, no answer required), C<request-response>
-(client initiated, the usual in both directions), C<solicit-response> (server
-initiated "challenge").
-
-=item method => 'POST'|'M-POST'
-
-With C<POST>, you get the standard HTTP exchange.  The C<M-POST> is
-implements the (Microsoft) HTTP Extension Framework.  Some servers
-accept both, other require a specific request.
-
-=item mime_type => STRING
-
-=item mpost_id => INTEGER
-
-With method C<M-POST>, the header extension fields require (any) number
-to be grouped.
-
-=item soap => 'SOAP11'|'SOAP12'|OBJECT
-
-=item xml_format => 0|1|2
-
-=back
-
-example: create a client
-
- my $trans = XML::Compile::Transport::SOAPHTTP->new
-   ( address => 'http://www.stockquoteserver.com/StockQuote'
-   );
-
- my $call = $trans->compileClient
-   ( action  => 'http://example.com/GetLastTradePrice'
-   );
-
- # $request and $answer are XML::LibXML trees!
- # see XML::Compile::SOAP::Client::compileClient() for wrapper which
- # converts from and to Perl data structures.
-
- my ($answer, $trace) = $call->($request);
- my $answer = $call->($request); # drop $trace info immediately
-
-=item $obj-E<gt>B<headerAddVersions>($header)
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<headerAddVersions>($header)
-
-Adds some lines about module versions, which may help debugging
-or error reports.  This is called when a new client or server
-is being created.
-
-=back
-
-=head1 DETAILS
-
-Extends L<"DETAILS" in XML::Compile::Transport|XML::Compile::Transport/"DETAILS">.
- 
-=head1 Helpers
-
-Extends L<"Helpers" in XML::Compile::Transport|XML::Compile::Transport/"Helpers">.
- 
-=over 4
-
-=item XML::Compile::Transport::SOAPHTTP-E<gt>B<register>($uri)
-
-Inherited, see L<XML::Compile::Transport/"Helpers">
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/XOP.pm b/lib/XML/Compile/XOP.pm
index 675b2e3..af16685 100644
--- a/lib/XML/Compile/XOP.pm
+++ b/lib/XML/Compile/XOP.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::XOP;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -25,6 +18,56 @@ XML::Compile->knownNamespace
   , &XMIME11   => '200505-xmlmime.xsd'
   );
 
+=chapter NAME
+XML::Compile::XOP - MTOM and XOP handler
+
+=chapter SYNOPSIS
+
+  # by default, XML::Compile encodes binary data
+  my $answer    = $call->(image => $binary_image);
+
+  # to enable use of MTOM
+  use XML::Compile::XOP;
+  my $xop       = XML::Compile::XOP->new;
+  my $xop_image = $xop->bytes($binary_image);
+  my $answer    = $call->(image => $xop_image);
+
+  # returned XOPs in SOAP
+  my ($answer, $trace, $xop) = $wsdl->call($operation)->(%data);
+  print $_->string for @$xop;   # See XML::Compile::XOP::Include
+
+=chapter DESCRIPTION
+The SOAP Message Transmission Optimization Mechanism (MTOM) is designed
+for SOAP1.2, but also usable for SOAP1.1.  It optimizes the transport of
+binary information (like images) which are part of the XML message: in
+stead of base64 encoding them adding 25% to the size of the data, these
+binaries are added as pure binary attachment to the SOAP message.
+
+In the official specification, the XML message will be created first
+with the base64 representation of the data in it. Only at transmission,
+a preprocessor XOP (XML-binary Optimized Packaging) extracts those
+components to be send separately.  In Perl, we have to be more careful
+about performance.  Therefore, the path via encoding to base64 and then
+decoding it back to binary in the sender (and the reverse process for
+the receiver) is avoided.
+
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+
+=option  xmlmime_version URI
+=default xmlmime_version XMIME11
+
+=option  xop_version     URI
+=default xop_version     XOP10
+
+=option  hostname        STRING
+=default hostname        'localhost'
+This is used as part of generated Content-IDs, which have the form of
+a email address.
+=cut
 
 sub new(@) { my $class = shift; (bless {})->init( {@_} ) }
 
@@ -38,6 +81,29 @@ sub init($)
     $self;
 }
 
+=method file <$filename|$fh>, %options
+Create a M<XML::Compile::XOP::Include> object which sources from a
+FILE specified by NAME or HANDLE.  With the %options, you can overrule
+defaults generated for the "Include" object.
+
+=example use of file()
+  use MIME::Types;
+  my $mimetypes = MIME::Types->new;
+
+  my $type = $mimetypes->mimeTypeOf($fn);
+  my $data = $xop->file($fn, type => $fn);
+  # $data is a XML::Compile::XOP::Include
+
+=method bytes <STRING|SCALAR>, %options
+Create a M<XML::Compile::XOP::Include> object which sources from a
+STRING (representing bytes) or a SCALAR reference to such a string.
+With the %options, you can overrule defaults generated for the "Include"
+object.
+
+=example use of bytes()
+  my $data = $xop->bytes($string, type => 'text/html');
+  # $data is a XML::Compile::XOP::Include
+=cut
 
 sub _include(@)
 {   my $self = shift;
@@ -52,5 +118,16 @@ sub _include(@)
 sub file(@)  { my $self = shift; $self->_include(file  => @_) }
 sub bytes(@) { my $self = shift; $self->_include(bytes => @_) }
 
+=chapter DETAILS
+
+=chapter SEE ALSO
+=over 4
+=item MTOM SOAP1.2: F<http://www.w3.org/TR/soap12-mtom/>
+=item MTOM SOAP1.1: F<http://schemas.xmlsoap.org/soap/mtom/SOAP11MTOM10.pdf>
+=item XOP: F<http://www.w3.org/TR/xop10/>
+=item XMLMIME: F<http://www.w3.org/TR/xml-media-types>
+=back
+
+=cut
 
 1;
diff --git a/lib/XML/Compile/XOP.pod b/lib/XML/Compile/XOP.pod
deleted file mode 100644
index 9fdf41c..0000000
--- a/lib/XML/Compile/XOP.pod
+++ /dev/null
@@ -1,121 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::XOP - MTOM and XOP handler
-
-=head1 SYNOPSIS
-
-  # by default, XML::Compile encodes binary data
-  my $answer    = $call->(image => $binary_image);
-
-  # to enable use of MTOM
-  use XML::Compile::XOP;
-  my $xop       = XML::Compile::XOP->new;
-  my $xop_image = $xop->bytes($binary_image);
-  my $answer    = $call->(image => $xop_image);
-
-  # returned XOPs in SOAP
-  my ($answer, $trace, $xop) = $wsdl->call($operation)->(%data);
-  print $_->string for @$xop;   # See XML::Compile::XOP::Include
-
-=head1 DESCRIPTION
-
-The SOAP Message Transmission Optimization Mechanism (MTOM) is designed
-for SOAP1.2, but also usable for SOAP1.1.  It optimizes the transport of
-binary information (like images) which are part of the XML message: in
-stead of base64 encoding them adding 25% to the size of the data, these
-binaries are added as pure binary attachment to the SOAP message.
-
-In the official specification, the XML message will be created first
-with the base64 representation of the data in it. Only at transmission,
-a preprocessor XOP (XML-binary Optimized Packaging) extracts those
-components to be send separately.  In Perl, we have to be more careful
-about performance.  Therefore, the path via encoding to base64 and then
-decoding it back to binary in the sender (and the reverse process for
-the receiver) is avoided.
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item $obj-E<gt>B<bytes>( <STRING|SCALAR>, %options )
-
-Create a L<XML::Compile::XOP::Include|XML::Compile::XOP::Include> object which sources from a
-STRING (representing bytes) or a SCALAR reference to such a string.
-With the %options, you can overrule defaults generated for the "Include"
-object.
-
-example: use of bytes()
-
-  my $data = $xop->bytes($string, type => 'text/html');
-  # $data is a XML::Compile::XOP::Include
-
-=item $obj-E<gt>B<file>( <$filename|$fh>, %options )
-
-Create a L<XML::Compile::XOP::Include|XML::Compile::XOP::Include> object which sources from a
-FILE specified by NAME or HANDLE.  With the %options, you can overrule
-defaults generated for the "Include" object.
-
-example: use of file()
-
-  use MIME::Types;
-  my $mimetypes = MIME::Types->new;
-
-  my $type = $mimetypes->mimeTypeOf($fn);
-  my $data = $xop->file($fn, type => $fn);
-  # $data is a XML::Compile::XOP::Include
-
-=item XML::Compile::XOP-E<gt>B<new>(%options)
-
- -Option         --Default
-  hostname         'localhost'
-  xmlmime_version  XMIME11
-  xop_version      XOP10
-
-=over 2
-
-=item hostname => STRING
-
-This is used as part of generated Content-IDs, which have the form of
-a email address.
-
-=item xmlmime_version => URI
-
-=item xop_version => URI
-
-=back
-
-=back
-
-=head1 DETAILS
-
-=head1 SEE ALSO
-
-=over 4
-
-=item MTOM SOAP1.2: F<http://www.w3.org/TR/soap12-mtom/>
-
-=item MTOM SOAP1.1: F<http://schemas.xmlsoap.org/soap/mtom/SOAP11MTOM10.pdf>
-
-=item XOP: F<http://www.w3.org/TR/xop10/>
-
-=item XMLMIME: F<http://www.w3.org/TR/xml-media-types>
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/lib/XML/Compile/XOP/Include.pm b/lib/XML/Compile/XOP/Include.pm
index 8191837..c5d1827 100644
--- a/lib/XML/Compile/XOP/Include.pm
+++ b/lib/XML/Compile/XOP/Include.pm
@@ -1,15 +1,8 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 # This code is part of distribution XML-Compile-SOAP.  Meta-POD processed
 # with OODoc into POD and HTML manual-pages.  See README.md
 # Copyright Mark Overmeer.  Licensed under the same terms as Perl itself.
 
 package XML::Compile::XOP::Include;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 
 use warnings;
 use strict;
@@ -20,10 +13,63 @@ use HTTP::Message     ();
 use File::Slurper     qw/read_binary write_binary/;
 use Encode            qw/decode FB_CROAK/;
 
+=chapter NAME
+XML::Compile::XOP::Include - Represents one XOP node.
+
+=chapter SYNOPSIS
+
+  # See also SYNOPSIS of XML::Compile::XOP
+  my $xop       = XML::Compile::XOP->new;
+  my $xop_image = $xop->bytes($binary_image);
+  my $answer    = $call->(image => $xop_image);
+
+=chapter DESCRIPTION
+Represents one data-set which will be represented as separate (binary)
+object during transport.  This can only be used on data fields which
+are base64Binary.
+
+YOU SHOULD NOT instantiate this kind of objects directly, but use the
+M<XML::Compile::XOP> method to create them.
+
+The object is overloaded to produce the contained data when a scalar is
+required, for instance when you call functions like "length".  This means
+that, hopefully, the end-user does not see much of a difference between
+data which is transported inline or packaged separately.
+
+=chapter OVERLOAD
+
+=overload  ""
+This object stringifies to its binary content.
+=cut
 
 use overload '""'     => 'content'
            , fallback => 1;
 
+=chapter METHODS
+
+=section Constructors
+
+=c_method new %options
+You have to specify either a C<file> or C<byte> source.  Otherwise, the
+constructor will return C<undef>.
+
+=option  file FILENAME|FILEHANDLE
+=default file C<undef>
+Take the data from the specified file.
+
+=option  bytes STRING|SCALAR
+=default bytes C<undef>
+Take the data from a STRING of reference.
+
+=requires cid   STRING
+The Content-ID of the binary attachment.
+
+=requires type MIMETYPE
+The MIME-Type of the data.
+
+=requires xmime VERSION
+=requires xop   VERSION
+=cut
 
 sub new(@)
 {   my ($class, %args) = @_;
@@ -32,6 +78,9 @@ sub new(@)
     bless \%args, $class;
 }
 
+=c_method fromMime $object
+Collect the data from a M<HTTP::Message> object.
+=cut
 
 sub fromMime($)
 {   my ($class, $http) = @_;
@@ -51,9 +100,18 @@ sub fromMime($)
      );
 }
 
+=section Accessors
+
+=method cid 
+Returns the Content-ID.
+=cut
 
 sub cid { shift->{cid} }
 
+=method content [$byref]
+Returns the content, when $byref (boolean) is true, then the value is
+returned by reference.
+=cut
 
 sub content(;$)
 {   my ($self, $byref) = @_;
@@ -66,6 +124,9 @@ sub content(;$)
     $byref ? $self->{bytes} : ${$self->{bytes}};
 }
 
+=method string
+Returns the content as string in Perl internal encoding.
+=cut
 
 sub string() {
 	my $self = shift;
@@ -73,11 +134,28 @@ sub string() {
     decode $cs, $self->content, FB_CROAK;
 }
 
+=method contentType
+Returns the media type included in the Content-Type header.
+
+=method contentCharset
+Returns the character set, as provided by the Content-Type header.
+
+=cut
 
 sub contentType()    { shift->{type} }
 sub contentCharset() { shift->{charset} }
 
 #---------
+=section Processing
+
+=method xmlNode $document, $path, $tag
+The $document will be used to construct the node from.  The $path
+is an indicator for the location of the node within the data
+structure (used in error messages).  The $tag is the prefixed name
+for the node to be created.
+
+Returned is an XML node to be included in the output tree.
+=cut
 
 sub xmlNode($$$$)
 {   my ($self, $doc, $path, $tag) = @_;
@@ -91,6 +169,11 @@ sub xmlNode($$$$)
     $node;
 }
 
+=method mimePart [$headers]
+Produce the message part which contains a normal mime representation
+of a binary file.  You may provide an initial $headers (M<HTTP::Headers>)
+object, or an ARRAY of headers to instantiate such an object.
+=cut
 
 sub mimePart(;$)
 {   my ($self, $headers) = @_;
@@ -105,6 +188,9 @@ sub mimePart(;$)
     $mime;
 }
 
+=method write $filename|$fh
+Write the content to the specified FILE.
+=cut
 
 sub write($)
 {   my ($self, $file) = @_;
diff --git a/lib/XML/Compile/XOP/Include.pod b/lib/XML/Compile/XOP/Include.pod
deleted file mode 100644
index 74251b0..0000000
--- a/lib/XML/Compile/XOP/Include.pod
+++ /dev/null
@@ -1,151 +0,0 @@
-=encoding utf8
-
-=head1 NAME
-
-XML::Compile::XOP::Include - Represents one XOP node.
-
-=head1 SYNOPSIS
-
-  # See also SYNOPSIS of XML::Compile::XOP
-  my $xop       = XML::Compile::XOP->new;
-  my $xop_image = $xop->bytes($binary_image);
-  my $answer    = $call->(image => $xop_image);
-
-=head1 DESCRIPTION
-
-Represents one data-set which will be represented as separate (binary)
-object during transport.  This can only be used on data fields which
-are base64Binary.
-
-YOU SHOULD NOT instantiate this kind of objects directly, but use the
-L<XML::Compile::XOP|XML::Compile::XOP> method to create them.
-
-The object is overloaded to produce the contained data when a scalar is
-required, for instance when you call functions like "length".  This means
-that, hopefully, the end-user does not see much of a difference between
-data which is transported inline or packaged separately.
-
-=head1 METHODS
-
-=head2 Constructors
-
-=over 4
-
-=item XML::Compile::XOP::Include-E<gt>B<fromMime>($object)
-
-Collect the data from a HTTP::Message object.
-
-=item XML::Compile::XOP::Include-E<gt>B<new>(%options)
-
-You have to specify either a C<file> or C<byte> source.  Otherwise, the
-constructor will return C<undef>.
-
- -Option--Default
-  bytes   undef
-  cid     <required>
-  file    undef
-  type    <required>
-  xmime   <required>
-  xop     <required>
-
-=over 2
-
-=item bytes => STRING|SCALAR
-
-Take the data from a STRING of reference.
-
-=item cid => STRING
-
-The Content-ID of the binary attachment.
-
-=item file => FILENAME|FILEHANDLE
-
-Take the data from the specified file.
-
-=item type => MIMETYPE
-
-The MIME-Type of the data.
-
-=item xmime => VERSION
-
-=item xop => VERSION
-
-=back
-
-=back
-
-=head2 Accessors
-
-=over 4
-
-=item $obj-E<gt>B<cid>()
-
-Returns the Content-ID.
-
-=item $obj-E<gt>B<content>( [$byref] )
-
-Returns the content, when $byref (boolean) is true, then the value is
-returned by reference.
-
-=item $obj-E<gt>B<contentCharset>()
-
-Returns the character set, as provided by the Content-Type header.
-
-=item $obj-E<gt>B<contentType>()
-
-Returns the media type included in the Content-Type header.
-
-=item $obj-E<gt>B<string>()
-
-Returns the content as string in Perl internal encoding.
-
-=back
-
-=head2 Processing
-
-=over 4
-
-=item $obj-E<gt>B<mimePart>( [$headers] )
-
-Produce the message part which contains a normal mime representation
-of a binary file.  You may provide an initial $headers (HTTP::Headers)
-object, or an ARRAY of headers to instantiate such an object.
-
-=item $obj-E<gt>B<write>($filename|$fh)
-
-Write the content to the specified FILE.
-
-=item $obj-E<gt>B<xmlNode>($document, $path, $tag)
-
-The $document will be used to construct the node from.  The $path
-is an indicator for the location of the node within the data
-structure (used in error messages).  The $tag is the prefixed name
-for the node to be created.
-
-Returned is an XML node to be included in the output tree.
-
-=back
-
-=head1 OVERLOAD
-
-=over 4
-
-=item overload: B<"">
-
-This object stringifies to its binary content.
-
-=back
-
-=head1 SEE ALSO
-
-This module is part of XML-Compile-SOAP distribution version 3.27,
-built on April 07, 2021. Website: F<http://perl.overmeer.net/CPAN/>
-
-=head1 LICENSE
-
-Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>]. For other contributors see ChangeLog.
-
-This program is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-See F<http://dev.perl.org/licenses/>
-
diff --git a/t/01use.t b/t/01use.t
old mode 100644
new mode 100755
diff --git a/t/10soap.t b/t/10soap.t
old mode 100644
new mode 100755
diff --git a/t/11soapfault.t b/t/11soapfault.t
old mode 100644
new mode 100755
diff --git a/t/12soapmust.t b/t/12soapmust.t
old mode 100644
new mode 100755
diff --git a/t/30charenc.t b/t/30charenc.t
old mode 100644
new mode 100755
diff --git a/t/60xop.t b/t/60xop.t
old mode 100644
new mode 100755
diff --git a/t/70enc11.t b/t/70enc11.t
old mode 100644
new mode 100755
diff --git a/t/TestTools.pm b/t/TestTools.pm
old mode 100644
new mode 100755
index 03d7e1c..1badec1
--- a/t/TestTools.pm
+++ b/t/TestTools.pm
@@ -1,7 +1,3 @@
-# Copyrights 2007-2021 by [Mark Overmeer <markov@cpan.org>].
-#  For other contributors see ChangeLog.
-# See the manual pages for details on the licensing terms.
-# Pod stripped from pm file by OODoc 2.02.
 use warnings;
 use strict;
 
@@ -9,9 +5,6 @@ use strict;
 use lib '../XMLCompile/lib', '../LogReport/lib', '../XMLTester/lib';
 
 package TestTools;
-use vars '$VERSION';
-$VERSION = '3.27';
-
 use base 'Exporter';
 
 use Test::More;
diff --git a/xt/99pod.t b/xt/99pod.t
old mode 100644
new mode 100755