From 7be09bed7f9acdf8a20362c49831dfb39fc4e7a4 Mon Sep 17 00:00:00 2001 From: Mark Wells Date: Fri, 2 Nov 2012 14:28:31 -0700 Subject: [PATCH] initial commit --- .gitignore | 6 + Changes | 5 + EZLocate.pm | 186 +++++++++++++++ EZLocate/Elements/answerChallenge.pm | 134 +++++++++++ EZLocate/Elements/answerChallengeResponse.pm | 134 +++++++++++ EZLocate/Elements/findAddress.pm | 153 ++++++++++++ EZLocate/Elements/findAddressResponse.pm | 142 ++++++++++++ EZLocate/Elements/findMultiAddress.pm | 155 +++++++++++++ EZLocate/Elements/findMultiAddressResponse.pm | 144 ++++++++++++ EZLocate/Elements/getAccountInfo.pm | 120 ++++++++++ EZLocate/Elements/getAccountInfoResponse.pm | 176 ++++++++++++++ EZLocate/Elements/getClientInfo.pm | 134 +++++++++++ EZLocate/Elements/getClientInfoResponse.pm | 134 +++++++++++ EZLocate/Elements/getMOTD.pm | 106 +++++++++ EZLocate/Elements/getMOTDResponse.pm | 120 ++++++++++ EZLocate/Elements/getRPS.pm | 120 ++++++++++ EZLocate/Elements/getRPSResponse.pm | 120 ++++++++++ EZLocate/Elements/getServiceDescription.pm | 134 +++++++++++ EZLocate/Elements/getServiceDescriptionResponse.pm | 221 ++++++++++++++++++ EZLocate/Elements/getServices.pm | 120 ++++++++++ EZLocate/Elements/getServicesResponse.pm | 139 +++++++++++ EZLocate/Elements/invalidateCredential.pm | 120 ++++++++++ EZLocate/Elements/invalidateCredentialResponse.pm | 120 ++++++++++ EZLocate/Elements/requestChallenge.pm | 134 +++++++++++ EZLocate/Elements/requestChallengeResponse.pm | 134 +++++++++++ EZLocate/Elements/testCredential.pm | 148 ++++++++++++ EZLocate/Elements/testCredentialResponse.pm | 162 +++++++++++++ .../Interfaces/Authentication/Authentication.pm | 244 +++++++++++++++++++ EZLocate/Interfaces/EZClient/EZClient.pm | 240 +++++++++++++++++++ EZLocate/Interfaces/Geocoding/Geocoding.pm | 257 +++++++++++++++++++++ EZLocate/Typemaps/Authentication.pm | 66 ++++++ EZLocate/Typemaps/EZClient.pm | 62 +++++ EZLocate/Typemaps/Geocoding.pm | 103 +++++++++ EZLocate/Types/Geocode.pm | 116 ++++++++++ EZLocate/Types/GeocodeSequence.pm | 110 +++++++++ EZLocate/Types/MatchType.pm | 120 ++++++++++ EZLocate/Types/MatchTypeSequence.pm | 106 +++++++++ EZLocate/Types/NameValue.pm | 111 +++++++++ EZLocate/Types/OutputField.pm | 120 ++++++++++ EZLocate/Types/OutputFieldSequence.pm | 106 +++++++++ EZLocate/Types/Record.pm | 105 +++++++++ EZLocate/Types/RecordSequence.pm | 107 +++++++++ MANIFEST | 48 ++++ Makefile.PL | 20 ++ README | 55 +++++ ignore.txt | 12 + t/00-load.t | 9 + t/manifest.t | 13 ++ t/pod-coverage.t | 18 ++ t/pod.t | 12 + 50 files changed, 5681 insertions(+) create mode 100644 .gitignore create mode 100644 Changes create mode 100644 EZLocate.pm create mode 100644 EZLocate/Elements/answerChallenge.pm create mode 100644 EZLocate/Elements/answerChallengeResponse.pm create mode 100644 EZLocate/Elements/findAddress.pm create mode 100644 EZLocate/Elements/findAddressResponse.pm create mode 100644 EZLocate/Elements/findMultiAddress.pm create mode 100644 EZLocate/Elements/findMultiAddressResponse.pm create mode 100644 EZLocate/Elements/getAccountInfo.pm create mode 100644 EZLocate/Elements/getAccountInfoResponse.pm create mode 100644 EZLocate/Elements/getClientInfo.pm create mode 100644 EZLocate/Elements/getClientInfoResponse.pm create mode 100644 EZLocate/Elements/getMOTD.pm create mode 100644 EZLocate/Elements/getMOTDResponse.pm create mode 100644 EZLocate/Elements/getRPS.pm create mode 100644 EZLocate/Elements/getRPSResponse.pm create mode 100644 EZLocate/Elements/getServiceDescription.pm create mode 100644 EZLocate/Elements/getServiceDescriptionResponse.pm create mode 100644 EZLocate/Elements/getServices.pm create mode 100644 EZLocate/Elements/getServicesResponse.pm create mode 100644 EZLocate/Elements/invalidateCredential.pm create mode 100644 EZLocate/Elements/invalidateCredentialResponse.pm create mode 100644 EZLocate/Elements/requestChallenge.pm create mode 100644 EZLocate/Elements/requestChallengeResponse.pm create mode 100644 EZLocate/Elements/testCredential.pm create mode 100644 EZLocate/Elements/testCredentialResponse.pm create mode 100644 EZLocate/Interfaces/Authentication/Authentication.pm create mode 100644 EZLocate/Interfaces/EZClient/EZClient.pm create mode 100644 EZLocate/Interfaces/Geocoding/Geocoding.pm create mode 100644 EZLocate/Typemaps/Authentication.pm create mode 100644 EZLocate/Typemaps/EZClient.pm create mode 100644 EZLocate/Typemaps/Geocoding.pm create mode 100644 EZLocate/Types/Geocode.pm create mode 100644 EZLocate/Types/GeocodeSequence.pm create mode 100644 EZLocate/Types/MatchType.pm create mode 100644 EZLocate/Types/MatchTypeSequence.pm create mode 100644 EZLocate/Types/NameValue.pm create mode 100644 EZLocate/Types/OutputField.pm create mode 100644 EZLocate/Types/OutputFieldSequence.pm create mode 100644 EZLocate/Types/Record.pm create mode 100644 EZLocate/Types/RecordSequence.pm create mode 100644 MANIFEST create mode 100644 Makefile.PL create mode 100644 README create mode 100644 ignore.txt create mode 100644 t/00-load.t create mode 100644 t/manifest.t create mode 100644 t/pod-coverage.t create mode 100644 t/pod.t diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9788afa --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +blib/ +*.sw? +Makefile +Makefile.old +MYMETA.yml +pm_to_blib diff --git a/Changes b/Changes new file mode 100644 index 0000000..379fd1e --- /dev/null +++ b/Changes @@ -0,0 +1,5 @@ +Revision history for Geo-EZLocate + +0.01 Date/time + First version, released on an unsuspecting world. + diff --git a/EZLocate.pm b/EZLocate.pm new file mode 100644 index 0000000..3215dc3 --- /dev/null +++ b/EZLocate.pm @@ -0,0 +1,186 @@ +package Geo::EZLocate; + +use 5.006; +use strict; +use warnings; + +use Geo::EZLocate::Interfaces::Authentication::Authentication; +use Geo::EZLocate::Interfaces::Geocoding::Geocoding; + +=head1 NAME + +Geo::EZLocate - TomTom EZLocate geocoding service interface + +=head1 VERSION + +Version 0.01 + +=cut + +our $VERSION = '0.01'; + +our $timeout = 10; # in minutes + +=head1 SYNOPSIS + + use Geo::EZLocate; + + my $geo = Geo::EZLocate->new(); + my $result = $geo->login('myusername', 'mypassword'); + $ + ... + +=head1 METHODS + +=head2 login USERNAME PASSWORD + +Authenticates and caches a login token. Returns the result code, which +is zero on success and nonzero on failure. + +=cut + +# shorthand class names + +my $Interfaces = 'Geo::EZLocate::Interfaces'; +my $Auth = $Interfaces.'::Authentication::Authentication'; +my $EZClient = $Interfaces.'::EZClient::EZClient'; +my $Geocoding = $Interfaces.'::Geocoding::Geocoding'; + +sub new { + my $class = shift; + # mimic the official API + my $username = shift; + my $password = shift; + return bless { username => $username, password => $password, @_ }, + 'Geo::EZLocate'; +} + +sub login { + my $self = shift; + + if ( $self->{identity} and (time - $self->{authtime}) < $timeout ) { + return; # no need to reauth + } + + my ($username, $password) = @_; + if ( $username ) { + $self->{username} = $username; + $self->{password} = $password; + } + + # preprocess key + my $key = 0; + for (split(//, $self->{password})) { + $key = ($key << 4) + ord($_); + my $bits = $key & 0xf0000000; + $bits >>= 24; + $key = ($key ^ $bits); + } + $key = $key & 0x3fffffff; + + my $client = $self->{'auth'} ||= $Auth->new; + my $r_requestChallenge = $client->requestChallenge({ + userName => $self->{username}, + minutesValid => $timeout, + }); + my $eid = $r_requestChallenge->get_encryptedID; + + # XOR $eid with key, multiply it by the magic number, XOR it back + my $ans = $eid ^ $key; + $ans = ($ans * 39371) % 0x3fffffff; + $ans = $ans ^ $key; + + my $r_answerChallenge = $client->answerChallenge({ + originalChallenge => $eid, + encryptedResponse => $ans, + }); + + my $id = $r_answerChallenge->get_credential; + if ( $id ) { + $self->{identity} = $id; + $self->{authtime} = time; + } + return $r_answerChallenge->get_resultCode; +} + +=head2 findAddress ADDRESS, CITY, STATE, ZIP, [OPTION => VALUE] ... + +Validate the specified address. The only OPTION that matters currently +is 'country', which can be set to "CA" to search for addresses in Canada. + +=cut + +sub findAddress { + my $self = shift; + my %params; + # again, imitate the positional parameters in the official SDK + $params{Addr} = shift; + $params{City} = shift; + $params{State} = shift; + $params{ZIP} = shift; + my %opt = @_; + + my $client = $self->{geocoding} ||= $Geocoding->new; + $self->login(); + die "authentication failed" unless $self->{identity}; + + my $service = 'USA_Geo_004'; + if ( lc($opt{'country'} || '') eq 'ca' ) { + $service = 'CAN_Geo_001'; + } + my $input = { + nv => [ map { +{ name => $_, value => $params{$_} } } keys %params ] + }; + my $r_findAddress = $client->findAddress({ + 'service' => $service, + 'identity' => $self->{identity}, + 'input' => $input, + }); + + my $nvs = $r_findAddress->get_result->get_mAttributes->get_nv; + + my $match = {}; + foreach my $nv (@$nvs) { + $match->{$nv->get_name} = '' . $nv->get_value; #force stringification + } + + $match; +} + +=head1 AUTHOR + +Mark Wells, C<< >> + +=head1 BUGS + +Much of the API is unsupported. The Geo::EZLocate::Interfaces::* +packages have autogenerated wrappers for all of the API methods, and +they work, but I haven't documented or tested most of them. + +This module shouldn't even be necessary, but the EZLocate SDK has a +restrictive license which makes it impractical for open-source +development. This is a shame, because their geocoding service is +very good. + +=head1 SUPPORT + +You can find documentation for this module with the perldoc command. + + perldoc Geo::EZLocate + +This library is not supported by TomTom. + +=head1 LICENSE AND COPYRIGHT + +Copyright 2012 Mark Wells. + +This program is free software; you can redistribute it and/or modify it +under the terms of either: the GNU General Public License as published +by the Free Software Foundation; or the Artistic License. + +See http://dev.perl.org/licenses/ for more information. + + +=cut + +1; # End of Geo::EZLocate diff --git a/EZLocate/Elements/answerChallenge.pm b/EZLocate/Elements/answerChallenge.pm new file mode 100644 index 0000000..02fb9d5 --- /dev/null +++ b/EZLocate/Elements/answerChallenge.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::answerChallenge; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('answerChallenge'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %encryptedResponse_of :ATTR(:get); +my %originalChallenge_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( encryptedResponse + originalChallenge + + ) ], + { + 'encryptedResponse' => \%encryptedResponse_of, + 'originalChallenge' => \%originalChallenge_of, + }, + { + 'encryptedResponse' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'originalChallenge' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'encryptedResponse' => 'encryptedResponse', + 'originalChallenge' => 'originalChallenge', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::answerChallenge + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +answerChallenge from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * encryptedResponse + + $element->set_encryptedResponse($data); + $element->get_encryptedResponse(); + + + + +=item * originalChallenge + + $element->set_originalChallenge($data); + $element->get_originalChallenge(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::answerChallenge->new($data); + +Constructor. The following data structure may be passed to new(): + + { + encryptedResponse => $some_value, # int + originalChallenge => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/answerChallengeResponse.pm b/EZLocate/Elements/answerChallengeResponse.pm new file mode 100644 index 0000000..a3c488a --- /dev/null +++ b/EZLocate/Elements/answerChallengeResponse.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::answerChallengeResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('answerChallengeResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %credential_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + credential + + ) ], + { + 'resultCode' => \%resultCode_of, + 'credential' => \%credential_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'resultCode' => 'resultCode', + 'credential' => 'credential', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::answerChallengeResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +answerChallengeResponse from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * credential + + $element->set_credential($data); + $element->get_credential(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::answerChallengeResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + credential => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/findAddress.pm b/EZLocate/Elements/findAddress.pm new file mode 100644 index 0000000..d8cbad8 --- /dev/null +++ b/EZLocate/Elements/findAddress.pm @@ -0,0 +1,153 @@ + +package Geo::EZLocate::Elements::findAddress; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('findAddress'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %service_of :ATTR(:get); +my %input_of :ATTR(:get); +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( service + input + identity + + ) ], + { + 'service' => \%service_of, + 'input' => \%input_of, + 'identity' => \%identity_of, + }, + { + 'service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'input' => 'Geo::EZLocate::Types::Record', + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'service' => 'service', + 'input' => 'input', + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::findAddress + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +findAddress from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * service + + $element->set_service($data); + $element->get_service(); + + + + +=item * input + + $element->set_input($data); + $element->get_input(); + + + + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::findAddress->new($data); + +Constructor. The following data structure may be passed to new(): + + { + service => $some_value, # string + input => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/findAddressResponse.pm b/EZLocate/Elements/findAddressResponse.pm new file mode 100644 index 0000000..4904c4a --- /dev/null +++ b/EZLocate/Elements/findAddressResponse.pm @@ -0,0 +1,142 @@ + +package Geo::EZLocate::Elements::findAddressResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('findAddressResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %result_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + result + + ) ], + { + 'resultCode' => \%resultCode_of, + 'result' => \%result_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'result' => 'Geo::EZLocate::Types::Geocode', + }, + { + + 'resultCode' => 'resultCode', + 'result' => 'result', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::findAddressResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +findAddressResponse from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * result + + $element->set_result($data); + $element->get_result(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::findAddressResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + result => { # Geo::EZLocate::Types::Geocode + resultCode => $some_value, # int + mAttributes => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/findMultiAddress.pm b/EZLocate/Elements/findMultiAddress.pm new file mode 100644 index 0000000..41fb781 --- /dev/null +++ b/EZLocate/Elements/findMultiAddress.pm @@ -0,0 +1,155 @@ + +package Geo::EZLocate::Elements::findMultiAddress; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('findMultiAddress'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %service_of :ATTR(:get); +my %inputs_of :ATTR(:get); +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( service + inputs + identity + + ) ], + { + 'service' => \%service_of, + 'inputs' => \%inputs_of, + 'identity' => \%identity_of, + }, + { + 'service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'inputs' => 'Geo::EZLocate::Types::RecordSequence', + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'service' => 'service', + 'inputs' => 'inputs', + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::findMultiAddress + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +findMultiAddress from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * service + + $element->set_service($data); + $element->get_service(); + + + + +=item * inputs + + $element->set_inputs($data); + $element->get_inputs(); + + + + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::findMultiAddress->new($data); + +Constructor. The following data structure may be passed to new(): + + { + service => $some_value, # string + inputs => { # Geo::EZLocate::Types::RecordSequence + record => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/findMultiAddressResponse.pm b/EZLocate/Elements/findMultiAddressResponse.pm new file mode 100644 index 0000000..fdec059 --- /dev/null +++ b/EZLocate/Elements/findMultiAddressResponse.pm @@ -0,0 +1,144 @@ + +package Geo::EZLocate::Elements::findMultiAddressResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('findMultiAddressResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %results_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + results + + ) ], + { + 'resultCode' => \%resultCode_of, + 'results' => \%results_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'results' => 'Geo::EZLocate::Types::GeocodeSequence', + }, + { + + 'resultCode' => 'resultCode', + 'results' => 'results', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::findMultiAddressResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +findMultiAddressResponse from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * results + + $element->set_results($data); + $element->get_results(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::findMultiAddressResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + results => { # Geo::EZLocate::Types::GeocodeSequence + sequence => { # Geo::EZLocate::Types::Geocode + resultCode => $some_value, # int + mAttributes => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + }, + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getAccountInfo.pm b/EZLocate/Elements/getAccountInfo.pm new file mode 100644 index 0000000..712e48e --- /dev/null +++ b/EZLocate/Elements/getAccountInfo.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::getAccountInfo; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getAccountInfo'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( identity + + ) ], + { + 'identity' => \%identity_of, + }, + { + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getAccountInfo + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getAccountInfo from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getAccountInfo->new($data); + +Constructor. The following data structure may be passed to new(): + + { + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getAccountInfoResponse.pm b/EZLocate/Elements/getAccountInfoResponse.pm new file mode 100644 index 0000000..21690d9 --- /dev/null +++ b/EZLocate/Elements/getAccountInfoResponse.pm @@ -0,0 +1,176 @@ + +package Geo::EZLocate::Elements::getAccountInfoResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getAccountInfoResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %expiration_of :ATTR(:get); +my %maximumRecords_of :ATTR(:get); +my %actualRecords_of :ATTR(:get); +my %accountType_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + expiration + maximumRecords + actualRecords + accountType + + ) ], + { + 'resultCode' => \%resultCode_of, + 'expiration' => \%expiration_of, + 'maximumRecords' => \%maximumRecords_of, + 'actualRecords' => \%actualRecords_of, + 'accountType' => \%accountType_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'expiration' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'maximumRecords' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'actualRecords' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'accountType' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + }, + { + + 'resultCode' => 'resultCode', + 'expiration' => 'expiration', + 'maximumRecords' => 'maximumRecords', + 'actualRecords' => 'actualRecords', + 'accountType' => 'accountType', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getAccountInfoResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getAccountInfoResponse from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * expiration + + $element->set_expiration($data); + $element->get_expiration(); + + + + +=item * maximumRecords + + $element->set_maximumRecords($data); + $element->get_maximumRecords(); + + + + +=item * actualRecords + + $element->set_actualRecords($data); + $element->get_actualRecords(); + + + + +=item * accountType + + $element->set_accountType($data); + $element->get_accountType(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getAccountInfoResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + expiration => $some_value, # string + maximumRecords => $some_value, # int + actualRecords => $some_value, # int + accountType => $some_value, # string + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getClientInfo.pm b/EZLocate/Elements/getClientInfo.pm new file mode 100644 index 0000000..c0955fe --- /dev/null +++ b/EZLocate/Elements/getClientInfo.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::getClientInfo; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getClientInfo'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %majorVersion_of :ATTR(:get); +my %minorVersion_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( majorVersion + minorVersion + + ) ], + { + 'majorVersion' => \%majorVersion_of, + 'minorVersion' => \%minorVersion_of, + }, + { + 'majorVersion' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'minorVersion' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'majorVersion' => 'majorVersion', + 'minorVersion' => 'minorVersion', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getClientInfo + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getClientInfo from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * majorVersion + + $element->set_majorVersion($data); + $element->get_majorVersion(); + + + + +=item * minorVersion + + $element->set_minorVersion($data); + $element->get_minorVersion(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getClientInfo->new($data); + +Constructor. The following data structure may be passed to new(): + + { + majorVersion => $some_value, # int + minorVersion => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getClientInfoResponse.pm b/EZLocate/Elements/getClientInfoResponse.pm new file mode 100644 index 0000000..35d153b --- /dev/null +++ b/EZLocate/Elements/getClientInfoResponse.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::getClientInfoResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getClientInfoResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %message_of :ATTR(:get); +my %safeToRun_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( message + safeToRun + + ) ], + { + 'message' => \%message_of, + 'safeToRun' => \%safeToRun_of, + }, + { + 'message' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'safeToRun' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'message' => 'message', + 'safeToRun' => 'safeToRun', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getClientInfoResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getClientInfoResponse from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * message + + $element->set_message($data); + $element->get_message(); + + + + +=item * safeToRun + + $element->set_safeToRun($data); + $element->get_safeToRun(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getClientInfoResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + message => $some_value, # string + safeToRun => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getMOTD.pm b/EZLocate/Elements/getMOTD.pm new file mode 100644 index 0000000..1e74f04 --- /dev/null +++ b/EZLocate/Elements/getMOTD.pm @@ -0,0 +1,106 @@ + +package Geo::EZLocate::Elements::getMOTD; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getMOTD'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + + +__PACKAGE__->_factory( + [ qw( + ) ], + { + }, + { + }, + { + + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getMOTD + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getMOTD from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getMOTD->new($data); + +Constructor. The following data structure may be passed to new(): + + { + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getMOTDResponse.pm b/EZLocate/Elements/getMOTDResponse.pm new file mode 100644 index 0000000..117a0ed --- /dev/null +++ b/EZLocate/Elements/getMOTDResponse.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::getMOTDResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getMOTDResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %message_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( message + + ) ], + { + 'message' => \%message_of, + }, + { + 'message' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + }, + { + + 'message' => 'message', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getMOTDResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getMOTDResponse from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * message + + $element->set_message($data); + $element->get_message(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getMOTDResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + message => $some_value, # string + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getRPS.pm b/EZLocate/Elements/getRPS.pm new file mode 100644 index 0000000..c9fb576 --- /dev/null +++ b/EZLocate/Elements/getRPS.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::getRPS; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getRPS'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( identity + + ) ], + { + 'identity' => \%identity_of, + }, + { + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getRPS + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getRPS from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getRPS->new($data); + +Constructor. The following data structure may be passed to new(): + + { + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getRPSResponse.pm b/EZLocate/Elements/getRPSResponse.pm new file mode 100644 index 0000000..a893a5a --- /dev/null +++ b/EZLocate/Elements/getRPSResponse.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::getRPSResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/EZClient.xsd1' } + +__PACKAGE__->__set_name('getRPSResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %recordsPerSecond_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( recordsPerSecond + + ) ], + { + 'recordsPerSecond' => \%recordsPerSecond_of, + }, + { + 'recordsPerSecond' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'recordsPerSecond' => 'recordsPerSecond', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getRPSResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getRPSResponse from the namespace http://ezlocate.na.teleatlas.com/EZClient.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * recordsPerSecond + + $element->set_recordsPerSecond($data); + $element->get_recordsPerSecond(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getRPSResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + recordsPerSecond => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getServiceDescription.pm b/EZLocate/Elements/getServiceDescription.pm new file mode 100644 index 0000000..d3e740d --- /dev/null +++ b/EZLocate/Elements/getServiceDescription.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::getServiceDescription; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('getServiceDescription'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %service_of :ATTR(:get); +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( service + identity + + ) ], + { + 'service' => \%service_of, + 'identity' => \%identity_of, + }, + { + 'service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'service' => 'service', + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getServiceDescription + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getServiceDescription from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * service + + $element->set_service($data); + $element->get_service(); + + + + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getServiceDescription->new($data); + +Constructor. The following data structure may be passed to new(): + + { + service => $some_value, # string + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getServiceDescriptionResponse.pm b/EZLocate/Elements/getServiceDescriptionResponse.pm new file mode 100644 index 0000000..4b9ecc1 --- /dev/null +++ b/EZLocate/Elements/getServiceDescriptionResponse.pm @@ -0,0 +1,221 @@ + +package Geo::EZLocate::Elements::getServiceDescriptionResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('getServiceDescriptionResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %description_of :ATTR(:get); +my %countryCode_of :ATTR(:get); +my %inputs_of :ATTR(:get); +my %outputs_of :ATTR(:get); +my %matchTypes_of :ATTR(:get); +my %matchTypeName_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + description + countryCode + inputs + outputs + matchTypes + matchTypeName + + ) ], + { + 'resultCode' => \%resultCode_of, + 'description' => \%description_of, + 'countryCode' => \%countryCode_of, + 'inputs' => \%inputs_of, + 'outputs' => \%outputs_of, + 'matchTypes' => \%matchTypes_of, + 'matchTypeName' => \%matchTypeName_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'countryCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'inputs' => 'Geo::EZLocate::Types::Record', + 'outputs' => 'Geo::EZLocate::Types::OutputFieldSequence', + 'matchTypes' => 'Geo::EZLocate::Types::MatchTypeSequence', + 'matchTypeName' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + }, + { + + 'resultCode' => 'resultCode', + 'description' => 'description', + 'countryCode' => 'countryCode', + 'inputs' => 'inputs', + 'outputs' => 'outputs', + 'matchTypes' => 'matchTypes', + 'matchTypeName' => 'matchTypeName', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getServiceDescriptionResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getServiceDescriptionResponse from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * description + + $element->set_description($data); + $element->get_description(); + + + + +=item * countryCode + + $element->set_countryCode($data); + $element->get_countryCode(); + + + + +=item * inputs + + $element->set_inputs($data); + $element->get_inputs(); + + + + +=item * outputs + + $element->set_outputs($data); + $element->get_outputs(); + + + + +=item * matchTypes + + $element->set_matchTypes($data); + $element->get_matchTypes(); + + + + +=item * matchTypeName + + $element->set_matchTypeName($data); + $element->get_matchTypeName(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getServiceDescriptionResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + description => $some_value, # string + countryCode => $some_value, # string + inputs => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + outputs => { # Geo::EZLocate::Types::OutputFieldSequence + fields => { # Geo::EZLocate::Types::OutputField + name => $some_value, # string + description => $some_value, # string + type => $some_value, # int + }, + }, + matchTypes => { # Geo::EZLocate::Types::MatchTypeSequence + types => { # Geo::EZLocate::Types::MatchType + name => $some_value, # string + description => $some_value, # string + id => $some_value, # int + }, + }, + matchTypeName => $some_value, # string + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getServices.pm b/EZLocate/Elements/getServices.pm new file mode 100644 index 0000000..3c70649 --- /dev/null +++ b/EZLocate/Elements/getServices.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::getServices; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('getServices'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %identity_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( identity + + ) ], + { + 'identity' => \%identity_of, + }, + { + 'identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'identity' => 'identity', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getServices + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getServices from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * identity + + $element->set_identity($data); + $element->get_identity(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getServices->new($data); + +Constructor. The following data structure may be passed to new(): + + { + identity => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/getServicesResponse.pm b/EZLocate/Elements/getServicesResponse.pm new file mode 100644 index 0000000..93f28ac --- /dev/null +++ b/EZLocate/Elements/getServicesResponse.pm @@ -0,0 +1,139 @@ + +package Geo::EZLocate::Elements::getServicesResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' } + +__PACKAGE__->__set_name('getServicesResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %services_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + services + + ) ], + { + 'resultCode' => \%resultCode_of, + 'services' => \%services_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'services' => 'Geo::EZLocate::Types::Record', + }, + { + + 'resultCode' => 'resultCode', + 'services' => 'services', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::getServicesResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +getServicesResponse from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * services + + $element->set_services($data); + $element->get_services(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::getServicesResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + services => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/invalidateCredential.pm b/EZLocate/Elements/invalidateCredential.pm new file mode 100644 index 0000000..7fb7ed4 --- /dev/null +++ b/EZLocate/Elements/invalidateCredential.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::invalidateCredential; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('invalidateCredential'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %credential_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( credential + + ) ], + { + 'credential' => \%credential_of, + }, + { + 'credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'credential' => 'credential', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::invalidateCredential + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +invalidateCredential from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * credential + + $element->set_credential($data); + $element->get_credential(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::invalidateCredential->new($data); + +Constructor. The following data structure may be passed to new(): + + { + credential => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/invalidateCredentialResponse.pm b/EZLocate/Elements/invalidateCredentialResponse.pm new file mode 100644 index 0000000..8b448f8 --- /dev/null +++ b/EZLocate/Elements/invalidateCredentialResponse.pm @@ -0,0 +1,120 @@ + +package Geo::EZLocate::Elements::invalidateCredentialResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('invalidateCredentialResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + + ) ], + { + 'resultCode' => \%resultCode_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'resultCode' => 'resultCode', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::invalidateCredentialResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +invalidateCredentialResponse from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::invalidateCredentialResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/requestChallenge.pm b/EZLocate/Elements/requestChallenge.pm new file mode 100644 index 0000000..682044e --- /dev/null +++ b/EZLocate/Elements/requestChallenge.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::requestChallenge; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('requestChallenge'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %userName_of :ATTR(:get); +my %minutesValid_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( userName + minutesValid + + ) ], + { + 'userName' => \%userName_of, + 'minutesValid' => \%minutesValid_of, + }, + { + 'userName' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'minutesValid' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'userName' => 'userName', + 'minutesValid' => 'minutesValid', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::requestChallenge + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +requestChallenge from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * userName + + $element->set_userName($data); + $element->get_userName(); + + + + +=item * minutesValid + + $element->set_minutesValid($data); + $element->get_minutesValid(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::requestChallenge->new($data); + +Constructor. The following data structure may be passed to new(): + + { + userName => $some_value, # string + minutesValid => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/requestChallengeResponse.pm b/EZLocate/Elements/requestChallengeResponse.pm new file mode 100644 index 0000000..c03951a --- /dev/null +++ b/EZLocate/Elements/requestChallengeResponse.pm @@ -0,0 +1,134 @@ + +package Geo::EZLocate::Elements::requestChallengeResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('requestChallengeResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %encryptedID_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + encryptedID + + ) ], + { + 'resultCode' => \%resultCode_of, + 'encryptedID' => \%encryptedID_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'encryptedID' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'resultCode' => 'resultCode', + 'encryptedID' => 'encryptedID', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::requestChallengeResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +requestChallengeResponse from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * encryptedID + + $element->set_encryptedID($data); + $element->get_encryptedID(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::requestChallengeResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + encryptedID => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/testCredential.pm b/EZLocate/Elements/testCredential.pm new file mode 100644 index 0000000..186e80a --- /dev/null +++ b/EZLocate/Elements/testCredential.pm @@ -0,0 +1,148 @@ + +package Geo::EZLocate::Elements::testCredential; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('testCredential'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %ipAddress_of :ATTR(:get); +my %credential_of :ATTR(:get); +my %serverCred_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( ipAddress + credential + serverCred + + ) ], + { + 'ipAddress' => \%ipAddress_of, + 'credential' => \%credential_of, + 'serverCred' => \%serverCred_of, + }, + { + 'ipAddress' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'serverCred' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'ipAddress' => 'ipAddress', + 'credential' => 'credential', + 'serverCred' => 'serverCred', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::testCredential + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +testCredential from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * ipAddress + + $element->set_ipAddress($data); + $element->get_ipAddress(); + + + + +=item * credential + + $element->set_credential($data); + $element->get_credential(); + + + + +=item * serverCred + + $element->set_serverCred($data); + $element->get_serverCred(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::testCredential->new($data); + +Constructor. The following data structure may be passed to new(): + + { + ipAddress => $some_value, # string + credential => $some_value, # int + serverCred => $some_value, # int + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Elements/testCredentialResponse.pm b/EZLocate/Elements/testCredentialResponse.pm new file mode 100644 index 0000000..8d7e917 --- /dev/null +++ b/EZLocate/Elements/testCredentialResponse.pm @@ -0,0 +1,162 @@ + +package Geo::EZLocate::Elements::testCredentialResponse; +use strict; +use warnings; + +{ # BLOCK to scope variables + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Authentication.xsd1' } + +__PACKAGE__->__set_name('testCredentialResponse'); +__PACKAGE__->__set_nillable(); +__PACKAGE__->__set_minOccurs(); +__PACKAGE__->__set_maxOccurs(); +__PACKAGE__->__set_ref(); + +use base qw( + SOAP::WSDL::XSD::Typelib::Element + SOAP::WSDL::XSD::Typelib::ComplexType +); + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %user_of :ATTR(:get); +my %password_of :ATTR(:get); +my %expiration_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + user + password + expiration + + ) ], + { + 'resultCode' => \%resultCode_of, + 'user' => \%user_of, + 'password' => \%password_of, + 'expiration' => \%expiration_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'user' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'password' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'expiration' => 'SOAP::WSDL::XSD::Typelib::Builtin::long', + }, + { + + 'resultCode' => 'resultCode', + 'user' => 'user', + 'password' => 'password', + 'expiration' => 'expiration', + } +); + +} # end BLOCK + + + + + + +} # end of BLOCK + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Elements::testCredentialResponse + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined element +testCredentialResponse from the namespace http://ezlocate.na.teleatlas.com/Authentication.xsd1. + + + + + + + +=head1 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + $element->set_resultCode($data); + $element->get_resultCode(); + + + + +=item * user + + $element->set_user($data); + $element->get_user(); + + + + +=item * password + + $element->set_password($data); + $element->get_password(); + + + + +=item * expiration + + $element->set_expiration($data); + $element->get_expiration(); + + + + + +=back + + +=head1 METHODS + +=head2 new + + my $element = Geo::EZLocate::Elements::testCredentialResponse->new($data); + +Constructor. The following data structure may be passed to new(): + + { + resultCode => $some_value, # int + user => $some_value, # string + password => $some_value, # string + expiration => $some_value, # long + }, + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Interfaces/Authentication/Authentication.pm b/EZLocate/Interfaces/Authentication/Authentication.pm new file mode 100644 index 0000000..1d18d5a --- /dev/null +++ b/EZLocate/Interfaces/Authentication/Authentication.pm @@ -0,0 +1,244 @@ +package Geo::EZLocate::Interfaces::Authentication::Authentication; +use strict; +use warnings; +use Class::Std::Fast::Storable; +use Scalar::Util qw(blessed); +use base qw(SOAP::WSDL::Client::Base); + +# only load if it hasn't been loaded before +require Geo::EZLocate::Typemaps::Authentication + if not Geo::EZLocate::Typemaps::Authentication->can('get_class'); + +sub START { + $_[0]->set_proxy('http://mmezl.teleatlas.com/axis/services/Authentication') if not $_[2]->{proxy}; + $_[0]->set_class_resolver('Geo::EZLocate::Typemaps::Authentication') + if not $_[2]->{class_resolver}; + + $_[0]->set_prefix($_[2]->{use_prefix}) if exists $_[2]->{use_prefix}; +} + +sub requestChallenge { + my ($self, $body, $header) = @_; + die "requestChallenge must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'requestChallenge', + soap_action => 'Authentication:AuthenticationPortType#requestChallenge', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::requestChallenge )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub answerChallenge { + my ($self, $body, $header) = @_; + die "answerChallenge must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'answerChallenge', + soap_action => 'Authentication:AuthenticationPortType#answerChallenge', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::answerChallenge )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub invalidateCredential { + my ($self, $body, $header) = @_; + die "invalidateCredential must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'invalidateCredential', + soap_action => 'Authentication:AuthenticationPortType#invalidateCredential', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::invalidateCredential )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub testCredential { + my ($self, $body, $header) = @_; + die "testCredential must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'testCredential', + soap_action => 'Authentication:AuthenticationPortType#testCredential', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::testCredential )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + + + +1; + + + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Interfaces::Authentication::Authentication - SOAP Interface for the Authentication Web Service + +=head1 SYNOPSIS + + use Geo::EZLocate::Interfaces::Authentication::Authentication; + my $interface = Geo::EZLocate::Interfaces::Authentication::Authentication->new(); + + my $response; + $response = $interface->requestChallenge(); + $response = $interface->answerChallenge(); + $response = $interface->invalidateCredential(); + $response = $interface->testCredential(); + + + +=head1 DESCRIPTION + +SOAP Interface for the Authentication web service +located at http://mmezl.teleatlas.com/axis/services/Authentication. + +=head1 SERVICE Authentication + + + +=head2 Port Authentication + + + +=head1 METHODS + +=head2 General methods + +=head3 new + +Constructor. + +All arguments are forwarded to L. + +=head2 SOAP Service methods + +Method synopsis is displayed with hash refs as parameters. + +The commented class names in the method's parameters denote that objects +of the corresponding class can be passed instead of the marked hash ref. + +You may pass any combination of objects, hash and list refs to these +methods, as long as you meet the structure. + +List items (i.e. multiple occurences) are not displayed in the synopsis. +You may generally pass a list ref of hash refs (or objects) instead of a hash +ref - this may result in invalid XML if used improperly, though. Note that +SOAP::WSDL always expects list references at maximum depth position. + +XML attributes are not displayed in this synopsis and cannot be set using +hash refs. See the respective class' documentation for additional information. + + + +=head3 requestChallenge + + + +Returns a L object. + + $response = $interface->requestChallenge( { + userName => $some_value, # string + minutesValid => $some_value, # int + },, + ); + +=head3 answerChallenge + + + +Returns a L object. + + $response = $interface->answerChallenge( { + encryptedResponse => $some_value, # int + originalChallenge => $some_value, # int + },, + ); + +=head3 invalidateCredential + + + +Returns a L object. + + $response = $interface->invalidateCredential( { + credential => $some_value, # int + },, + ); + +=head3 testCredential + + + +Returns a L object. + + $response = $interface->testCredential( { + ipAddress => $some_value, # string + credential => $some_value, # int + serverCred => $some_value, # int + },, + ); + + + +=head1 AUTHOR + +Generated by SOAP::WSDL on Fri Nov 2 14:12:51 2012 + +=cut diff --git a/EZLocate/Interfaces/EZClient/EZClient.pm b/EZLocate/Interfaces/EZClient/EZClient.pm new file mode 100644 index 0000000..fc55c5a --- /dev/null +++ b/EZLocate/Interfaces/EZClient/EZClient.pm @@ -0,0 +1,240 @@ +package Geo::EZLocate::Interfaces::EZClient::EZClient; +use strict; +use warnings; +use Class::Std::Fast::Storable; +use Scalar::Util qw(blessed); +use base qw(SOAP::WSDL::Client::Base); + +# only load if it hasn't been loaded before +require Geo::EZLocate::Typemaps::EZClient + if not Geo::EZLocate::Typemaps::EZClient->can('get_class'); + +sub START { + $_[0]->set_proxy('http://mmezl.teleatlas.com/axis/services/EZClient') if not $_[2]->{proxy}; + $_[0]->set_class_resolver('Geo::EZLocate::Typemaps::EZClient') + if not $_[2]->{class_resolver}; + + $_[0]->set_prefix($_[2]->{use_prefix}) if exists $_[2]->{use_prefix}; +} + +sub getMOTD { + my ($self, $body, $header) = @_; + die "getMOTD must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getMOTD', + soap_action => 'EZClient:EZClientPortType#getMOTD', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getMOTD )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub getClientInfo { + my ($self, $body, $header) = @_; + die "getClientInfo must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getClientInfo', + soap_action => 'EZClient:EZClientPortType#getClientInfo', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getClientInfo )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub getAccountInfo { + my ($self, $body, $header) = @_; + die "getAccountInfo must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getAccountInfo', + soap_action => 'EZClient:EZClientPortType#getAccountInfo', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getAccountInfo )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub getRPS { + my ($self, $body, $header) = @_; + die "getRPS must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getRPS', + soap_action => 'EZClient:EZClientPortType#getRPS', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getRPS )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + + + +1; + + + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Interfaces::EZClient::EZClient - SOAP Interface for the EZClient Web Service + +=head1 SYNOPSIS + + use Geo::EZLocate::Interfaces::EZClient::EZClient; + my $interface = Geo::EZLocate::Interfaces::EZClient::EZClient->new(); + + my $response; + $response = $interface->getMOTD(); + $response = $interface->getClientInfo(); + $response = $interface->getAccountInfo(); + $response = $interface->getRPS(); + + + +=head1 DESCRIPTION + +SOAP Interface for the EZClient web service +located at http://mmezl.teleatlas.com/axis/services/EZClient. + +=head1 SERVICE EZClient + + + +=head2 Port EZClient + + + +=head1 METHODS + +=head2 General methods + +=head3 new + +Constructor. + +All arguments are forwarded to L. + +=head2 SOAP Service methods + +Method synopsis is displayed with hash refs as parameters. + +The commented class names in the method's parameters denote that objects +of the corresponding class can be passed instead of the marked hash ref. + +You may pass any combination of objects, hash and list refs to these +methods, as long as you meet the structure. + +List items (i.e. multiple occurences) are not displayed in the synopsis. +You may generally pass a list ref of hash refs (or objects) instead of a hash +ref - this may result in invalid XML if used improperly, though. Note that +SOAP::WSDL always expects list references at maximum depth position. + +XML attributes are not displayed in this synopsis and cannot be set using +hash refs. See the respective class' documentation for additional information. + + + +=head3 getMOTD + + + +Returns a L object. + + $response = $interface->getMOTD( { + },, + ); + +=head3 getClientInfo + + + +Returns a L object. + + $response = $interface->getClientInfo( { + majorVersion => $some_value, # int + minorVersion => $some_value, # int + },, + ); + +=head3 getAccountInfo + + + +Returns a L object. + + $response = $interface->getAccountInfo( { + identity => $some_value, # int + },, + ); + +=head3 getRPS + + + +Returns a L object. + + $response = $interface->getRPS( { + identity => $some_value, # int + },, + ); + + + +=head1 AUTHOR + +Generated by SOAP::WSDL on Fri Nov 2 14:13:07 2012 + +=cut diff --git a/EZLocate/Interfaces/Geocoding/Geocoding.pm b/EZLocate/Interfaces/Geocoding/Geocoding.pm new file mode 100644 index 0000000..2ac0927 --- /dev/null +++ b/EZLocate/Interfaces/Geocoding/Geocoding.pm @@ -0,0 +1,257 @@ +package Geo::EZLocate::Interfaces::Geocoding::Geocoding; +use strict; +use warnings; +use Class::Std::Fast::Storable; +use Scalar::Util qw(blessed); +use base qw(SOAP::WSDL::Client::Base); + +# only load if it hasn't been loaded before +require Geo::EZLocate::Typemaps::Geocoding + if not Geo::EZLocate::Typemaps::Geocoding->can('get_class'); + +sub START { + $_[0]->set_proxy('http://mmezl.teleatlas.com/axis/services/Geocoding') if not $_[2]->{proxy}; + $_[0]->set_class_resolver('Geo::EZLocate::Typemaps::Geocoding') + if not $_[2]->{class_resolver}; + + $_[0]->set_prefix($_[2]->{use_prefix}) if exists $_[2]->{use_prefix}; +} + +sub getServices { + my ($self, $body, $header) = @_; + die "getServices must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getServices', + soap_action => 'Geocoding:GeocodingPortType#getServices', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getServices )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub getServiceDescription { + my ($self, $body, $header) = @_; + die "getServiceDescription must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'getServiceDescription', + soap_action => 'Geocoding:GeocodingPortType#getServiceDescription', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::getServiceDescription )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub findAddress { + my ($self, $body, $header) = @_; + die "findAddress must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'findAddress', + soap_action => 'Geocoding:GeocodingPortType#findAddress', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::findAddress )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + +sub findMultiAddress { + my ($self, $body, $header) = @_; + die "findMultiAddress must be called as object method (\$self is <$self>)" if not blessed($self); + return $self->SUPER::call({ + operation => 'findMultiAddress', + soap_action => 'Geocoding:GeocodingPortType#findMultiAddress', + style => 'document', + body => { + + + 'use' => 'literal', + namespace => 'http://schemas.xmlsoap.org/wsdl/soap/', + encodingStyle => '', + parts => [qw( Geo::EZLocate::Elements::findMultiAddress )], + }, + header => { + + }, + headerfault => { + + } + }, $body, $header); +} + + + + +1; + + + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Interfaces::Geocoding::Geocoding - SOAP Interface for the Geocoding Web Service + +=head1 SYNOPSIS + + use Geo::EZLocate::Interfaces::Geocoding::Geocoding; + my $interface = Geo::EZLocate::Interfaces::Geocoding::Geocoding->new(); + + my $response; + $response = $interface->getServices(); + $response = $interface->getServiceDescription(); + $response = $interface->findAddress(); + $response = $interface->findMultiAddress(); + + + +=head1 DESCRIPTION + +SOAP Interface for the Geocoding web service +located at http://mmezl.teleatlas.com/axis/services/Geocoding. + +=head1 SERVICE Geocoding + + + +=head2 Port Geocoding + + + +=head1 METHODS + +=head2 General methods + +=head3 new + +Constructor. + +All arguments are forwarded to L. + +=head2 SOAP Service methods + +Method synopsis is displayed with hash refs as parameters. + +The commented class names in the method's parameters denote that objects +of the corresponding class can be passed instead of the marked hash ref. + +You may pass any combination of objects, hash and list refs to these +methods, as long as you meet the structure. + +List items (i.e. multiple occurences) are not displayed in the synopsis. +You may generally pass a list ref of hash refs (or objects) instead of a hash +ref - this may result in invalid XML if used improperly, though. Note that +SOAP::WSDL always expects list references at maximum depth position. + +XML attributes are not displayed in this synopsis and cannot be set using +hash refs. See the respective class' documentation for additional information. + + + +=head3 getServices + + + +Returns a L object. + + $response = $interface->getServices( { + identity => $some_value, # int + },, + ); + +=head3 getServiceDescription + + + +Returns a L object. + + $response = $interface->getServiceDescription( { + service => $some_value, # string + identity => $some_value, # int + },, + ); + +=head3 findAddress + + + +Returns a L object. + + $response = $interface->findAddress( { + service => $some_value, # string + input => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + identity => $some_value, # int + },, + ); + +=head3 findMultiAddress + + + +Returns a L object. + + $response = $interface->findMultiAddress( { + service => $some_value, # string + inputs => { # Geo::EZLocate::Types::RecordSequence + record => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + identity => $some_value, # int + },, + ); + + + +=head1 AUTHOR + +Generated by SOAP::WSDL on Fri Nov 2 14:12:17 2012 + +=cut diff --git a/EZLocate/Typemaps/Authentication.pm b/EZLocate/Typemaps/Authentication.pm new file mode 100644 index 0000000..4461aca --- /dev/null +++ b/EZLocate/Typemaps/Authentication.pm @@ -0,0 +1,66 @@ + +package Geo::EZLocate::Typemaps::Authentication; +use strict; +use warnings; + +our $typemap_1 = { + 'invalidateCredentialResponse' => 'Geo::EZLocate::Elements::invalidateCredentialResponse', + 'requestChallenge' => 'Geo::EZLocate::Elements::requestChallenge', + 'testCredentialResponse/user' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'testCredentialResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'testCredential/ipAddress' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'answerChallenge' => 'Geo::EZLocate::Elements::answerChallenge', + 'requestChallengeResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'answerChallenge/encryptedResponse' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault/faultcode' => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI', + 'invalidateCredential' => 'Geo::EZLocate::Elements::invalidateCredential', + 'answerChallengeResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'requestChallengeResponse/encryptedID' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'testCredential' => 'Geo::EZLocate::Elements::testCredential', + 'Fault/faultstring' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'testCredential/credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'testCredentialResponse/password' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault' => 'SOAP::WSDL::SOAP::Typelib::Fault11', + 'answerChallenge/originalChallenge' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault/faultactor' => 'SOAP::WSDL::XSD::Typelib::Builtin::token', + 'requestChallengeResponse' => 'Geo::EZLocate::Elements::requestChallengeResponse', + 'testCredentialResponse/expiration' => 'SOAP::WSDL::XSD::Typelib::Builtin::long', + 'Fault/detail' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'answerChallengeResponse/credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'testCredential/serverCred' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'answerChallengeResponse' => 'Geo::EZLocate::Elements::answerChallengeResponse', + 'testCredentialResponse' => 'Geo::EZLocate::Elements::testCredentialResponse', + 'requestChallenge/minutesValid' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'invalidateCredentialResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'requestChallenge/userName' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'invalidateCredential/credential' => 'SOAP::WSDL::XSD::Typelib::Builtin::int' + }; +; + +sub get_class { + my $name = join '/', @{ $_[1] }; + return $typemap_1->{ $name }; +} + +sub get_typemap { + return $typemap_1; +} + +1; + +__END__ + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Typemaps::Authentication - typemap for Authentication + +=head1 DESCRIPTION + +Typemap created by SOAP::WSDL for map-based SOAP message parsers. + +=cut + diff --git a/EZLocate/Typemaps/EZClient.pm b/EZLocate/Typemaps/EZClient.pm new file mode 100644 index 0000000..83937b9 --- /dev/null +++ b/EZLocate/Typemaps/EZClient.pm @@ -0,0 +1,62 @@ + +package Geo::EZLocate::Typemaps::EZClient; +use strict; +use warnings; + +our $typemap_1 = { + 'getRPSResponse' => 'Geo::EZLocate::Elements::getRPSResponse', + 'getMOTDResponse' => 'Geo::EZLocate::Elements::getMOTDResponse', + 'getAccountInfo' => 'Geo::EZLocate::Elements::getAccountInfo', + 'getAccountInfoResponse/accountType' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getAccountInfoResponse' => 'Geo::EZLocate::Elements::getAccountInfoResponse', + 'getClientInfo' => 'Geo::EZLocate::Elements::getClientInfo', + 'getAccountInfoResponse/actualRecords' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault/faultcode' => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI', + 'getAccountInfoResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getMOTDResponse/message' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault/faultstring' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getClientInfoResponse' => 'Geo::EZLocate::Elements::getClientInfoResponse', + 'getClientInfoResponse/safeToRun' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getClientInfo/minorVersion' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault' => 'SOAP::WSDL::SOAP::Typelib::Fault11', + 'getAccountInfoResponse/expiration' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault/faultactor' => 'SOAP::WSDL::XSD::Typelib::Builtin::token', + 'getClientInfoResponse/message' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getRPS/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault/detail' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getAccountInfoResponse/maximumRecords' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getClientInfo/majorVersion' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getRPSResponse/recordsPerSecond' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getMOTD' => 'Geo::EZLocate::Elements::getMOTD', + 'getAccountInfo/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getRPS' => 'Geo::EZLocate::Elements::getRPS' + }; +; + +sub get_class { + my $name = join '/', @{ $_[1] }; + return $typemap_1->{ $name }; +} + +sub get_typemap { + return $typemap_1; +} + +1; + +__END__ + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Typemaps::EZClient - typemap for EZClient + +=head1 DESCRIPTION + +Typemap created by SOAP::WSDL for map-based SOAP message parsers. + +=cut + diff --git a/EZLocate/Typemaps/Geocoding.pm b/EZLocate/Typemaps/Geocoding.pm new file mode 100644 index 0000000..edb21c7 --- /dev/null +++ b/EZLocate/Typemaps/Geocoding.pm @@ -0,0 +1,103 @@ + +package Geo::EZLocate::Typemaps::Geocoding; +use strict; +use warnings; + +our $typemap_1 = { + 'getServiceDescriptionResponse/inputs' => 'Geo::EZLocate::Types::Record', + 'findMultiAddressResponse/results/sequence/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServicesResponse/services/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findAddress/input/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault/faultcode' => 'SOAP::WSDL::XSD::Typelib::Builtin::anyURI', + 'findMultiAddress/inputs/record/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServices' => 'Geo::EZLocate::Elements::getServices', + 'getServicesResponse/services/nv' => 'Geo::EZLocate::Types::NameValue', + 'findAddressResponse' => 'Geo::EZLocate::Elements::findAddressResponse', + 'findAddress/input/nv' => 'Geo::EZLocate::Types::NameValue', + 'getServicesResponse/services/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse' => 'Geo::EZLocate::Elements::getServiceDescriptionResponse', + 'getServiceDescriptionResponse/matchTypes' => 'Geo::EZLocate::Types::MatchTypeSequence', + 'findAddressResponse/result/mAttributes/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/matchTypes/types' => 'Geo::EZLocate::Types::MatchType', + 'findMultiAddressResponse/results/sequence/mAttributes/nv' => 'Geo::EZLocate::Types::NameValue', + 'findMultiAddressResponse' => 'Geo::EZLocate::Elements::findMultiAddressResponse', + 'findMultiAddress/inputs/record/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/outputs/fields/description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findAddress' => 'Geo::EZLocate::Elements::findAddress', + 'getServices/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'findMultiAddressResponse/results' => 'Geo::EZLocate::Types::GeocodeSequence', + 'findMultiAddressResponse/results/sequence' => 'Geo::EZLocate::Types::Geocode', + 'getServiceDescriptionResponse/inputs/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddressResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'findAddress/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'findAddressResponse/result/mAttributes/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault/faultstring' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/outputs' => 'Geo::EZLocate::Types::OutputFieldSequence', + 'findAddress/input' => 'Geo::EZLocate::Types::Record', + 'getServiceDescriptionResponse/description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findAddress/service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findAddressResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServicesResponse' => 'Geo::EZLocate::Elements::getServicesResponse', + 'Fault/detail' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddress/inputs' => 'Geo::EZLocate::Types::RecordSequence', + 'findAddressResponse/result' => 'Geo::EZLocate::Types::Geocode', + 'findAddressResponse/result/mAttributes/nv' => 'Geo::EZLocate::Types::NameValue', + 'findMultiAddressResponse/results/sequence/mAttributes' => 'Geo::EZLocate::Types::Record', + 'getServiceDescriptionResponse/inputs/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddress/inputs/record' => 'Geo::EZLocate::Types::Record', + 'findAddressResponse/result/mAttributes' => 'Geo::EZLocate::Types::Record', + 'getServiceDescription/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'findMultiAddress/identity' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServiceDescription' => 'Geo::EZLocate::Elements::getServiceDescription', + 'findMultiAddress/service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddress/inputs/record/nv' => 'Geo::EZLocate::Types::NameValue', + 'getServicesResponse/services' => 'Geo::EZLocate::Types::Record', + 'findAddressResponse/result/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'findMultiAddress' => 'Geo::EZLocate::Elements::findMultiAddress', + 'getServiceDescriptionResponse/matchTypeName' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescription/service' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddressResponse/results/sequence/mAttributes/nv/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'findMultiAddressResponse/results/sequence/mAttributes/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/outputs/fields/type' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServiceDescriptionResponse/outputs/fields/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServicesResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServiceDescriptionResponse/resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'getServiceDescriptionResponse/matchTypes/types/description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/outputs/fields' => 'Geo::EZLocate::Types::OutputField', + 'getServiceDescriptionResponse/matchTypes/types/id' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'Fault' => 'SOAP::WSDL::SOAP::Typelib::Fault11', + 'findAddress/input/nv/value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'Fault/faultactor' => 'SOAP::WSDL::XSD::Typelib::Builtin::token', + 'getServiceDescriptionResponse/inputs/nv' => 'Geo::EZLocate::Types::NameValue', + 'getServiceDescriptionResponse/countryCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'getServiceDescriptionResponse/matchTypes/types/name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string' + }; +; + +sub get_class { + my $name = join '/', @{ $_[1] }; + return $typemap_1->{ $name }; +} + +sub get_typemap { + return $typemap_1; +} + +1; + +__END__ + +__END__ + +=pod + +=head1 NAME + +Geo::EZLocate::Typemaps::Geocoding - typemap for Geocoding + +=head1 DESCRIPTION + +Typemap created by SOAP::WSDL for map-based SOAP message parsers. + +=cut + diff --git a/EZLocate/Types/Geocode.pm b/EZLocate/Types/Geocode.pm new file mode 100644 index 0000000..f5741c1 --- /dev/null +++ b/EZLocate/Types/Geocode.pm @@ -0,0 +1,116 @@ +package Geo::EZLocate::Types::Geocode; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %resultCode_of :ATTR(:get); +my %mAttributes_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( resultCode + mAttributes + + ) ], + { + 'resultCode' => \%resultCode_of, + 'mAttributes' => \%mAttributes_of, + }, + { + 'resultCode' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + 'mAttributes' => 'Geo::EZLocate::Types::Record', + }, + { + + 'resultCode' => 'resultCode', + 'mAttributes' => 'mAttributes', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::Geocode + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +Geocode from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * resultCode + + +=item * mAttributes + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::Geocode + resultCode => $some_value, # int + mAttributes => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/GeocodeSequence.pm b/EZLocate/Types/GeocodeSequence.pm new file mode 100644 index 0000000..b07fde4 --- /dev/null +++ b/EZLocate/Types/GeocodeSequence.pm @@ -0,0 +1,110 @@ +package Geo::EZLocate::Types::GeocodeSequence; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %sequence_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( sequence + + ) ], + { + 'sequence' => \%sequence_of, + }, + { + 'sequence' => 'Geo::EZLocate::Types::Geocode', + }, + { + + 'sequence' => 'sequence', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::GeocodeSequence + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +GeocodeSequence from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * sequence + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::GeocodeSequence + sequence => { # Geo::EZLocate::Types::Geocode + resultCode => $some_value, # int + mAttributes => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/MatchType.pm b/EZLocate/Types/MatchType.pm new file mode 100644 index 0000000..997c60c --- /dev/null +++ b/EZLocate/Types/MatchType.pm @@ -0,0 +1,120 @@ +package Geo::EZLocate::Types::MatchType; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %name_of :ATTR(:get); +my %description_of :ATTR(:get); +my %id_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( name + description + id + + ) ], + { + 'name' => \%name_of, + 'description' => \%description_of, + 'id' => \%id_of, + }, + { + 'name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'id' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'name' => 'name', + 'description' => 'description', + 'id' => 'id', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::MatchType + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +MatchType from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * name + + +=item * description + + +=item * id + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::MatchType + name => $some_value, # string + description => $some_value, # string + id => $some_value, # int + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/MatchTypeSequence.pm b/EZLocate/Types/MatchTypeSequence.pm new file mode 100644 index 0000000..1ccfb56 --- /dev/null +++ b/EZLocate/Types/MatchTypeSequence.pm @@ -0,0 +1,106 @@ +package Geo::EZLocate::Types::MatchTypeSequence; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %types_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( types + + ) ], + { + 'types' => \%types_of, + }, + { + 'types' => 'Geo::EZLocate::Types::MatchType', + }, + { + + 'types' => 'types', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::MatchTypeSequence + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +MatchTypeSequence from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * types + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::MatchTypeSequence + types => { # Geo::EZLocate::Types::MatchType + name => $some_value, # string + description => $some_value, # string + id => $some_value, # int + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/NameValue.pm b/EZLocate/Types/NameValue.pm new file mode 100644 index 0000000..98070a7 --- /dev/null +++ b/EZLocate/Types/NameValue.pm @@ -0,0 +1,111 @@ +package Geo::EZLocate::Types::NameValue; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %name_of :ATTR(:get); +my %value_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( name + value + + ) ], + { + 'name' => \%name_of, + 'value' => \%value_of, + }, + { + 'name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'value' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + }, + { + + 'name' => 'name', + 'value' => 'value', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::NameValue + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +NameValue from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * name + + +=item * value + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/OutputField.pm b/EZLocate/Types/OutputField.pm new file mode 100644 index 0000000..b7e237e --- /dev/null +++ b/EZLocate/Types/OutputField.pm @@ -0,0 +1,120 @@ +package Geo::EZLocate::Types::OutputField; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %name_of :ATTR(:get); +my %description_of :ATTR(:get); +my %type_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( name + description + type + + ) ], + { + 'name' => \%name_of, + 'description' => \%description_of, + 'type' => \%type_of, + }, + { + 'name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'description' => 'SOAP::WSDL::XSD::Typelib::Builtin::string', + 'type' => 'SOAP::WSDL::XSD::Typelib::Builtin::int', + }, + { + + 'name' => 'name', + 'description' => 'description', + 'type' => 'type', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::OutputField + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +OutputField from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * name + + +=item * description + + +=item * type + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::OutputField + name => $some_value, # string + description => $some_value, # string + type => $some_value, # int + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/OutputFieldSequence.pm b/EZLocate/Types/OutputFieldSequence.pm new file mode 100644 index 0000000..eb79a5a --- /dev/null +++ b/EZLocate/Types/OutputFieldSequence.pm @@ -0,0 +1,106 @@ +package Geo::EZLocate::Types::OutputFieldSequence; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %fields_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( fields + + ) ], + { + 'fields' => \%fields_of, + }, + { + 'fields' => 'Geo::EZLocate::Types::OutputField', + }, + { + + 'fields' => 'fields', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::OutputFieldSequence + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +OutputFieldSequence from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * fields + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::OutputFieldSequence + fields => { # Geo::EZLocate::Types::OutputField + name => $some_value, # string + description => $some_value, # string + type => $some_value, # int + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/Record.pm b/EZLocate/Types/Record.pm new file mode 100644 index 0000000..96f2c90 --- /dev/null +++ b/EZLocate/Types/Record.pm @@ -0,0 +1,105 @@ +package Geo::EZLocate::Types::Record; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %nv_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( nv + + ) ], + { + 'nv' => \%nv_of, + }, + { + 'nv' => 'Geo::EZLocate::Types::NameValue', + }, + { + + 'nv' => 'nv', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::Record + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +Record from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * nv + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/EZLocate/Types/RecordSequence.pm b/EZLocate/Types/RecordSequence.pm new file mode 100644 index 0000000..c5293d8 --- /dev/null +++ b/EZLocate/Types/RecordSequence.pm @@ -0,0 +1,107 @@ +package Geo::EZLocate::Types::RecordSequence; +use strict; +use warnings; + + +__PACKAGE__->_set_element_form_qualified(0); + +sub get_xmlns { 'http://ezlocate.na.teleatlas.com/Geocoding.xsd1' }; + +our $XML_ATTRIBUTE_CLASS; +undef $XML_ATTRIBUTE_CLASS; + +sub __get_attr_class { + return $XML_ATTRIBUTE_CLASS; +} + +use Class::Std::Fast::Storable constructor => 'none'; +use base qw(SOAP::WSDL::XSD::Typelib::ComplexType); + +Class::Std::initialize(); + +{ # BLOCK to scope variables + +my %record_of :ATTR(:get); + +__PACKAGE__->_factory( + [ qw( record + + ) ], + { + 'record' => \%record_of, + }, + { + 'record' => 'Geo::EZLocate::Types::Record', + }, + { + + 'record' => 'record', + } +); + +} # end BLOCK + + + + + + + +1; + + +=pod + +=head1 NAME + +Geo::EZLocate::Types::RecordSequence + +=head1 DESCRIPTION + +Perl data type class for the XML Schema defined complexType +RecordSequence from the namespace http://ezlocate.na.teleatlas.com/Geocoding.xsd1. + + + + + + +=head2 PROPERTIES + +The following properties may be accessed using get_PROPERTY / set_PROPERTY +methods: + +=over + +=item * record + + + + +=back + + +=head1 METHODS + +=head2 new + +Constructor. The following data structure may be passed to new(): + + { # Geo::EZLocate::Types::RecordSequence + record => { # Geo::EZLocate::Types::Record + nv => { # Geo::EZLocate::Types::NameValue + name => $some_value, # string + value => $some_value, # string + }, + }, + }, + + + + +=head1 AUTHOR + +Generated by SOAP::WSDL + +=cut + diff --git a/MANIFEST b/MANIFEST new file mode 100644 index 0000000..984fbcc --- /dev/null +++ b/MANIFEST @@ -0,0 +1,48 @@ +Changes +EZLocate.pm +Makefile.PL +MANIFEST This list of files +README +t/00-load.t +t/manifest.t +t/pod-coverage.t +t/pod.t +EZLocate/Elements/requestChallenge.pm +EZLocate/Elements/getServiceDescription.pm +EZLocate/Elements/findMultiAddress.pm +EZLocate/Elements/getServices.pm +EZLocate/Elements/getMOTD.pm +EZLocate/Elements/getServiceDescriptionResponse.pm +EZLocate/Elements/getServicesResponse.pm +EZLocate/Elements/findMultiAddressResponse.pm +EZLocate/Elements/answerChallengeResponse.pm +EZLocate/Elements/getMOTDResponse.pm +EZLocate/Elements/getRPSResponse.pm +EZLocate/Elements/getClientInfo.pm +EZLocate/Elements/invalidateCredentialResponse.pm +EZLocate/Elements/testCredential.pm +EZLocate/Elements/getAccountInfoResponse.pm +EZLocate/Elements/getRPS.pm +EZLocate/Elements/getAccountInfo.pm +EZLocate/Elements/getClientInfoResponse.pm +EZLocate/Elements/findAddressResponse.pm +EZLocate/Elements/invalidateCredential.pm +EZLocate/Elements/answerChallenge.pm +EZLocate/Elements/testCredentialResponse.pm +EZLocate/Elements/requestChallengeResponse.pm +EZLocate/Elements/findAddress.pm +EZLocate/Types/MatchTypeSequence.pm +EZLocate/Types/GeocodeSequence.pm +EZLocate/Types/Record.pm +EZLocate/Types/OutputFieldSequence.pm +EZLocate/Types/MatchType.pm +EZLocate/Types/Geocode.pm +EZLocate/Types/OutputField.pm +EZLocate/Types/NameValue.pm +EZLocate/Types/RecordSequence.pm +EZLocate/Typemaps/Geocoding.pm +EZLocate/Typemaps/Authentication.pm +EZLocate/Typemaps/EZClient.pm +EZLocate/Interfaces/Geocoding/Geocoding.pm +EZLocate/Interfaces/EZClient/EZClient.pm +EZLocate/Interfaces/Authentication/Authentication.pm diff --git a/Makefile.PL b/Makefile.PL new file mode 100644 index 0000000..0098f49 --- /dev/null +++ b/Makefile.PL @@ -0,0 +1,20 @@ +use 5.006; +use strict; +use warnings; +use ExtUtils::MakeMaker; + +WriteMakefile( + NAME => 'Geo::EZLocate', + AUTHOR => q{Mark Wells }, + VERSION_FROM => 'EZLocate.pm', + ABSTRACT_FROM => 'EZLocate.pm', + ($ExtUtils::MakeMaker::VERSION >= 6.3002 + ? ('LICENSE'=> 'perl') + : ()), + PL_FILES => {}, + PREREQ_PM => { + 'Test::More' => 0, + }, + dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', }, + clean => { FILES => 'Geo-EZLocate-*' }, +); diff --git a/README b/README new file mode 100644 index 0000000..e7c2877 --- /dev/null +++ b/README @@ -0,0 +1,55 @@ +Geo-EZLocate + +The README is used to introduce the module and provide instructions on +how to install the module, any machine dependencies it may have (for +example C compilers and installed libraries) and any other information +that should be provided before the module is installed. + +A README file is required for CPAN modules since CPAN extracts the README +file from a module distribution so that people browsing the archive +can use it to get an idea of the module's uses. It is usually a good idea +to provide version information here so that people can decide whether +fixes for the module are worth downloading. + + +INSTALLATION + +To install this module, run the following commands: + + perl Makefile.PL + make + make test + make install + +SUPPORT AND DOCUMENTATION + +After installing, you can find documentation for this module with the +perldoc command. + + perldoc Geo::EZLocate + +You can also look for information at: + + RT, CPAN's request tracker (report bugs here) + http://rt.cpan.org/NoAuth/Bugs.html?Dist=Geo-EZLocate + + AnnoCPAN, Annotated CPAN documentation + http://annocpan.org/dist/Geo-EZLocate + + CPAN Ratings + http://cpanratings.perl.org/d/Geo-EZLocate + + Search CPAN + http://search.cpan.org/dist/Geo-EZLocate/ + + +LICENSE AND COPYRIGHT + +Copyright (C) 2012 Mark Wells + +This program is free software; you can redistribute it and/or modify it +under the terms of either: the GNU General Public License as published +by the Free Software Foundation; or the Artistic License. + +See http://dev.perl.org/licenses/ for more information. + diff --git a/ignore.txt b/ignore.txt new file mode 100644 index 0000000..01923a7 --- /dev/null +++ b/ignore.txt @@ -0,0 +1,12 @@ +blib* +Makefile +Makefile.old +Build +Build.bat +_build* +pm_to_blib* +*.tar.gz +.lwpcookies +cover_db +pod2htm*.tmp +Geo-EZLocate-* diff --git a/t/00-load.t b/t/00-load.t new file mode 100644 index 0000000..6027a67 --- /dev/null +++ b/t/00-load.t @@ -0,0 +1,9 @@ +#!perl -T + +use Test::More tests => 1; + +BEGIN { + use_ok( 'Geo::EZLocate' ) || print "Bail out!\n"; +} + +diag( "Testing Geo::EZLocate $Geo::EZLocate::VERSION, Perl $], $^X" ); diff --git a/t/manifest.t b/t/manifest.t new file mode 100644 index 0000000..45eb83f --- /dev/null +++ b/t/manifest.t @@ -0,0 +1,13 @@ +#!perl -T + +use strict; +use warnings; +use Test::More; + +unless ( $ENV{RELEASE_TESTING} ) { + plan( skip_all => "Author tests not required for installation" ); +} + +eval "use Test::CheckManifest 0.9"; +plan skip_all => "Test::CheckManifest 0.9 required" if $@; +ok_manifest(); diff --git a/t/pod-coverage.t b/t/pod-coverage.t new file mode 100644 index 0000000..fc40a57 --- /dev/null +++ b/t/pod-coverage.t @@ -0,0 +1,18 @@ +use strict; +use warnings; +use Test::More; + +# Ensure a recent version of Test::Pod::Coverage +my $min_tpc = 1.08; +eval "use Test::Pod::Coverage $min_tpc"; +plan skip_all => "Test::Pod::Coverage $min_tpc required for testing POD coverage" + if $@; + +# Test::Pod::Coverage doesn't require a minimum Pod::Coverage version, +# but older versions don't recognize some common documentation styles +my $min_pc = 0.18; +eval "use Pod::Coverage $min_pc"; +plan skip_all => "Pod::Coverage $min_pc required for testing POD coverage" + if $@; + +all_pod_coverage_ok(); diff --git a/t/pod.t b/t/pod.t new file mode 100644 index 0000000..ee8b18a --- /dev/null +++ b/t/pod.t @@ -0,0 +1,12 @@ +#!perl -T + +use strict; +use warnings; +use Test::More; + +# Ensure a recent version of Test::Pod +my $min_tp = 1.22; +eval "use Test::Pod $min_tp"; +plan skip_all => "Test::Pod $min_tp required for testing POD" if $@; + +all_pod_files_ok(); -- 2.11.0