File Coverage

blib/lib/ZCS/Admin/Interfaces/Admin/AdminSoap12.pm

Criterion	Covered	Total	%
statement	15	15	100.0
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	20	20	100.0

package ZCS::Admin::Interfaces::Admin::AdminSoap12;
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 ZCS::Admin::Typemaps::Admin
    if not ZCS::Admin::Typemaps::Admin->can('get_class');

sub START {
    $_[0]->set_proxy('https://localhost:7071/service/admin/soap') if not $_[2]->{proxy};
    $_[0]->set_class_resolver('ZCS::Admin::Typemaps::Admin')
        if not $_[2]->{class_resolver};

    $_[0]->set_prefix($_[2]->{use_prefix}) if exists $_[2]->{use_prefix};
}

sub Auth {
    my ($self, $body, $header) = @_;
    die "Auth must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'Auth',
        soap_action => 'urn:zimbraAdmin/Auth',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::AuthRequest )],
        },
        header => {

        },
        headerfault => {

        }
    }, $body, $header);
}


sub DelegateAuth {
    my ($self, $body, $header) = @_;
    die "DelegateAuth must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DelegateAuth',
        soap_action => 'urn:zimbraAdmin/DelegateAuth',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DelegateAuthRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub SearchDirectory {
    my ($self, $body, $header) = @_;
    die "SearchDirectory must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'SearchDirectory',
        soap_action => 'urn:zimbraAdmin/SearchDirectory',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::SearchDirectoryRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub CreateDomain {
    my ($self, $body, $header) = @_;
    die "CreateDomain must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'CreateDomain',
        soap_action => 'urn:zimbraAdmin/CreateDomain',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::CreateDomainRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub ModifyDomain {
    my ($self, $body, $header) = @_;
    die "ModifyDomain must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'ModifyDomain',
        soap_action => 'urn:zimbraAdmin/ModifyDomain',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::ModifyDomainRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetDomain {
    my ($self, $body, $header) = @_;
    die "GetDomain must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetDomain',
        soap_action => 'urn:zimbraAdmin/GetDomain',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetDomainRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAllDomains {
    my ($self, $body, $header) = @_;
    die "GetAllDomains must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAllDomains',
        soap_action => 'urn:zimbraAdmin/GetAllDomains',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAllDomainsRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub DeleteDomain {
    my ($self, $body, $header) = @_;
    die "DeleteDomain must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DeleteDomain',
        soap_action => 'urn:zimbraAdmin/DeleteDomain',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DeleteDomainRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetServer {
    my ($self, $body, $header) = @_;
    die "GetServer must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetServer',
        soap_action => 'urn:zimbraAdmin/GetServer',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetServerRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAllServers {
    my ($self, $body, $header) = @_;
    die "GetAllServers must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAllServers',
        soap_action => 'urn:zimbraAdmin/GetAllServers',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAllServersRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub CreateCos {
    my ($self, $body, $header) = @_;
    die "CreateCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'CreateCos',
        soap_action => 'urn:zimbraAdmin/CreateCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::CreateCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetCos {
    my ($self, $body, $header) = @_;
    die "GetCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetCos',
        soap_action => 'urn:zimbraAdmin/GetCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAllCos {
    my ($self, $body, $header) = @_;
    die "GetAllCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAllCos',
        soap_action => 'urn:zimbraAdmin/GetAllCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAllCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub ModifyCos {
    my ($self, $body, $header) = @_;
    die "ModifyCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'ModifyCos',
        soap_action => 'urn:zimbraAdmin/ModifyCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::ModifyCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub RenameCos {
    my ($self, $body, $header) = @_;
    die "RenameCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'RenameCos',
        soap_action => 'urn:zimbraAdmin/RenameCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::RenameCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub DeleteCos {
    my ($self, $body, $header) = @_;
    die "DeleteCos must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DeleteCos',
        soap_action => 'urn:zimbraAdmin/DeleteCos',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DeleteCosRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub CreateAccount {
    my ($self, $body, $header) = @_;
    die "CreateAccount must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'CreateAccount',
        soap_action => 'urn:zimbraAdmin/CreateAccount',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::CreateAccountRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub ModifyAccount {
    my ($self, $body, $header) = @_;
    die "ModifyAccount must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'ModifyAccount',
        soap_action => 'urn:zimbraAdmin/ModifyAccount',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::ModifyAccountRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub RenameAccount {
    my ($self, $body, $header) = @_;
    die "RenameAccount must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'RenameAccount',
        soap_action => 'urn:zimbraAdmin/RenameAccount',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::RenameAccountRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        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 => 'urn:zimbraAdmin/GetAccountInfo',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAccountInfoRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAccount {
    my ($self, $body, $header) = @_;
    die "GetAccount must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAccount',
        soap_action => 'urn:zimbraAdmin/GetAccount',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAccountRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAccountMembership {
    my ($self, $body, $header) = @_;
    die "GetAccountMembership must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAccountMembership',
        soap_action => 'urn:zimbraAdmin/GetAccountMembership',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAccountMembershipRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAllAccounts {
    my ($self, $body, $header) = @_;
    die "GetAllAccounts must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAllAccounts',
        soap_action => 'urn:zimbraAdmin/GetAllAccounts',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAllAccountsRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetAllAdminAccounts {
    my ($self, $body, $header) = @_;
    die "GetAllAdminAccounts must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetAllAdminAccounts',
        soap_action => 'urn:zimbraAdmin/GetAllAdminAccounts',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetAllAdminAccountsRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub DeleteAccount {
    my ($self, $body, $header) = @_;
    die "DeleteAccount must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DeleteAccount',
        soap_action => 'urn:zimbraAdmin/DeleteAccount',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DeleteAccountRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub CheckPasswordStrength {
    my ($self, $body, $header) = @_;
    die "CheckPasswordStrength must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'CheckPasswordStrength',
        soap_action => 'urn:zimbraAdmin/CheckPasswordStrength',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::CheckPasswordStrengthRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub SetPassword {
    my ($self, $body, $header) = @_;
    die "SetPassword must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'SetPassword',
        soap_action => 'urn:zimbraAdmin/SetPassword',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::SetPasswordRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub AddAccountAlias {
    my ($self, $body, $header) = @_;
    die "AddAccountAlias must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'AddAccountAlias',
        soap_action => 'urn:zimbraAdmin/AddAccountAlias',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::AddAccountAliasRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub RemoveAccountAlias {
    my ($self, $body, $header) = @_;
    die "RemoveAccountAlias must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'RemoveAccountAlias',
        soap_action => 'urn:zimbraAdmin/RemoveAccountAlias',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::RemoveAccountAliasRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub EnableArchive {
    my ($self, $body, $header) = @_;
    die "EnableArchive must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'EnableArchive',
        soap_action => 'urn:zimbraAdmin/EnableArchive',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::EnableArchiveRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub DisableArchive {
    my ($self, $body, $header) = @_;
    die "DisableArchive must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DisableArchive',
        soap_action => 'urn:zimbraAdmin/DisableArchive',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DisableArchiveRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub ExportMailbox {
    my ($self, $body, $header) = @_;
    die "ExportMailbox must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'ExportMailbox',
        soap_action => 'urn:zimbraAdmin/ExportMailbox',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::ExportMailboxRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub PurgeMovedMailbox {
    my ($self, $body, $header) = @_;
    die "PurgeMovedMailbox must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'PurgeMovedMailbox',
        soap_action => 'urn:zimbraAdmin/PurgeMovedMailbox',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::PurgeMovedMailboxRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GetDistributionList {
    my ($self, $body, $header) = @_;
    die "GetDistributionList must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GetDistributionList',
        soap_action => 'urn:zimbraAdmin/GetDistributionList',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GetDistributionListRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub CreateDistributionList {
    my ($self, $body, $header) = @_;
    die "CreateDistributionList must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'CreateDistributionList',
        soap_action => 'urn:zimbraAdmin/CreateDistributionList',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::CreateDistributionListRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub DeleteDistributionList {
    my ($self, $body, $header) = @_;
    die "DeleteDistributionList must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'DeleteDistributionList',
        soap_action => 'urn:zimbraAdmin/DeleteDistributionList',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::DeleteDistributionListRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub GrantRight {
    my ($self, $body, $header) = @_;
    die "GrantRight must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'GrantRight',
        soap_action => 'urn:zimbraAdmin/GrantRight',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::GrantRightRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}


sub RevokeRight {
    my ($self, $body, $header) = @_;
    die "RevokeRight must be called as object method (\$self is <$self>)" if not blessed($self);
    return $self->SUPER::call({
        operation => 'RevokeRight',
        soap_action => 'urn:zimbraAdmin/RevokeRight',
        style => 'document',
        body => {


           'use'            => 'literal',
            namespace       => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle   => '',
            parts           =>  [qw( ZCS::Admin::Elements::RevokeRightRequest )],
        },
        header => {



           'use' => 'literal',
            namespace => 'http://schemas.xmlsoap.org/wsdl/soap/',
            encodingStyle => '',
            parts => [qw( ZCS::Admin::Elements::context )],
        },
        headerfault => {

        }
    }, $body, $header);
}




1;



__END__