diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Extensions.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Extensions.cs new file mode 100644 index 00000000..9f98f99f --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Extensions.cs @@ -0,0 +1,59 @@ +// Copyright (c) 2012, Outercurve Foundation. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// - Neither the name of the Outercurve Foundation nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace WebsitePanel.Providers.Mail.SM10.Extensions +{ + public static class MailAccountExtensions + { + /// + /// Prepares all the necessary parameters to call SetUserSettings web method. + /// + /// + /// + public static string[] PrepareSetRequestedUserSettingsWebMethodParams(this MailAccount mailbox) + { + return new string[] { + "isenabled=" + mailbox.Enabled.ToString(), + // Fix for incorrect mailbox size + "maxsize=" + (mailbox.UnlimitedSize ? "0" : mailbox.MaxMailboxSize.ToString()), + "lockpassword=" + mailbox.PasswordLocked.ToString(), + "passwordlocked" + mailbox.PasswordLocked.ToString(), + "replytoaddress=" + (mailbox.ReplyTo != null ? mailbox.ReplyTo : ""), + "signature=" + (mailbox.Signature != null ? mailbox.Signature : ""), + "spamforwardoption=none", + // Set UTF8 as default encoding for webmail + "textencoding=65001" + }; + } + } +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/AssemblyInfo.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..1e05b9a4 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("WebsitePanel.Providers.Mail.SmarterMail10")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("WebsitePanel.Providers.Mail.SmarterMail10")] +[assembly: AssemblyCopyright("Copyright © 2012")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("9988b1a8-db89-44de-b440-b07def74cc25")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.Designer.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.Designer.cs new file mode 100644 index 00000000..822b5319 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.269 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace WebsitePanel.Providers.Mail.SmarterMail10.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WebsitePanel.Providers.Mail.SmarterMail10.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.resx b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.resx new file mode 100644 index 00000000..ffecec85 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.Designer.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.Designer.cs new file mode 100644 index 00000000..8b0ece65 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.269 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace WebsitePanel.Providers.Mail.SmarterMail10.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.settings b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.settings new file mode 100644 index 00000000..abf36c5d --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10.cs new file mode 100644 index 00000000..97ece705 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10.cs @@ -0,0 +1,2175 @@ +// Copyright (c) 2012, Outercurve Foundation. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// - Neither the name of the Outercurve Foundation nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Web.Services.Protocols; +using WebsitePanel.Mail.SM10; +using WebsitePanel.Providers; +using WebsitePanel.Providers.Common; +using WebsitePanel.Providers.Mail; +using WebsitePanel.Server.Utils; +using Microsoft.Win32; +using FileUtils = WebsitePanel.Providers.Utils.FileUtils; +using WebsitePanel.Providers.Mail.SM10.Extensions; + +namespace WebsitePanel.Providers.Mail +{ + class SmarterMail10 : HostingServiceProviderBase, IMailServer + { + static string[] smListSettings = new string[] { + "description", + "disabled", + "moderator", + "password", + "requirepassword", + "whocanpost", + "prependsubject", + "maxmessagesize", + //"maxrecipients", + "replytolist", + "subject", + //"listtoaddress", + //"listfromaddress", + //"listreplytoaddress", + "digestmode", + "sendsubscribe", + "sendunsubscribe", + "allowunsubscribe", + "disablelistcommand", + "disablesubscribecommand" + }; + + #region Public Properties + + protected string AdminUsername + { + get { return ProviderSettings["AdminUsername"]; } + } + + protected string AdminPassword + { + get { return ProviderSettings["AdminPassword"]; } + } + + protected bool ImportDomainAdmin + { + get + { + bool res; + bool.TryParse(ProviderSettings[Constants.ImportDomainAdmin], out res); + return res; + } + } + + protected bool InheritDomainDefaultLimits + { + get + { + bool res; + bool.TryParse(ProviderSettings[Constants.InheritDomainDefaultLimits], out res); + return res; + } + } + + protected bool EnableDomainAdministrators + { + get + { + bool res; + bool.TryParse(ProviderSettings[Constants.EnableDomainAdministrators], out res); + return res; + } + } + + protected string DomainsPath + { + get { return FileUtils.EvaluateSystemVariables(ProviderSettings["DomainsPath"]); } + } + + protected string ServerIP + { + get + { + string val = ProviderSettings["ServerIPAddress"]; + if (String.IsNullOrEmpty(val)) + return "127.0.0.1"; + + string ip = val.Trim(); + if (ip.IndexOf(";") > -1) + { + string[] ips = ip.Split(';'); + ip = String.IsNullOrEmpty(ips[1]) ? ips[0] : ips[1]; // get internal IP part + } + return ip; + } + } + + protected string ServiceUrl + { + get { return ProviderSettings["ServiceUrl"]; } + } + #endregion + + #region Constants + public const string SYSTEM_DOMAIN_ADMIN = "system.domain.admin"; + public const string SYSTEM_CATCH_ALL = "system.catch.all"; + #endregion + + #region IHostingServiceProvier methods + + public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled) + { + foreach (ServiceProviderItem item in items) + { + if (item is MailDomain) + { + try + { + // enable/disable mail domain + if (DomainExists(item.Name)) + { + MailDomain mailDomain = GetDomain(item.Name); + mailDomain.Enabled = enabled; + UpdateDomain(mailDomain); + } + } + catch (Exception ex) + { + Log.WriteError(String.Format("Error switching '{0}' SmarterMail domain", item.Name), ex); + } + } + } + } + + public override void DeleteServiceItems(ServiceProviderItem[] items) + { + foreach (ServiceProviderItem item in items) + { + if (item is MailDomain) + { + try + { + // delete mail domain + DeleteDomain(item.Name); + } + catch (Exception ex) + { + Log.WriteError(String.Format("Error deleting '{0}' SmarterMail domain", item.Name), ex); + } + } + } + } + + public override ServiceProviderItemDiskSpace[] GetServiceItemsDiskSpace(ServiceProviderItem[] items) + { + List itemsDiskspace = new List(); + + // update items with diskspace + foreach (ServiceProviderItem item in items) + { + if (item is MailAccount) + { + try + { + + // get mailbox size + string name = item.Name; + + // try to get SmarterMail postoffices path + string poPath = DomainsPath; + if (poPath == null) + continue; + + string mailboxName = name.Substring(0, name.IndexOf("@")); + string domainName = name.Substring(name.IndexOf("@") + 1); + + string mailboxPath = Path.Combine(DomainsPath, String.Format("{0}\\Users\\{1}", domainName, mailboxName)); + + Log.WriteStart(String.Format("Calculating '{0}' folder size", mailboxPath)); + + // calculate disk space + ServiceProviderItemDiskSpace diskspace = new ServiceProviderItemDiskSpace(); + diskspace.ItemId = item.Id; + //diskspace.DiskSpace = 0; + diskspace.DiskSpace = FileUtils.CalculateFolderSize(mailboxPath); + itemsDiskspace.Add(diskspace); + Log.WriteEnd(String.Format("Calculating '{0}' folder size", mailboxPath)); + } + catch (Exception ex) + { + Log.WriteError(ex); + } + } + } + return itemsDiskspace.ToArray(); + } + + public override ServiceProviderItemBandwidth[] GetServiceItemsBandwidth(ServiceProviderItem[] items, DateTime since) + { + ServiceProviderItemBandwidth[] itemsBandwidth = new ServiceProviderItemBandwidth[items.Length]; + + // update items with diskspace + for (int i = 0; i < items.Length; i++) + { + ServiceProviderItem item = items[i]; + + // create new bandwidth object + itemsBandwidth[i] = new ServiceProviderItemBandwidth(); + itemsBandwidth[i].ItemId = item.Id; + itemsBandwidth[i].Days = new DailyStatistics[0]; + + if (item is MailDomain) + { + try + { + // get daily statistics + itemsBandwidth[i].Days = GetDailyStatistics(since, item.Name); + } + catch (Exception ex) + { + Log.WriteError(ex); + System.Diagnostics.Debug.WriteLine(ex); + } + } + } + + return itemsBandwidth; + } + + public DailyStatistics[] GetDailyStatistics(DateTime since, string maildomainName) + { + + ArrayList days = new ArrayList(); + // read statistics + DateTime now = DateTime.Now; + DateTime date = since; + + try + { + while (date < now) + { + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + StatInfoResult result = + domains.GetDomainStatistics(AdminUsername, AdminPassword, maildomainName, date, date); + + if (!result.Result) + throw new Exception(result.Message); + + if (result.BytesReceived != 0 | result.BytesSent != 0) + { + DailyStatistics dailyStats = new DailyStatistics(); + dailyStats.Year = date.Year; + dailyStats.Month = date.Month; + dailyStats.Day = date.Day; + dailyStats.BytesSent = result.BytesSent; + dailyStats.BytesReceived = result.BytesReceived; + days.Add(dailyStats); + } + + // advance day + date = date.AddDays(1); + } + } + catch (Exception ex) + { + Log.WriteError("Could not get SmarterMail domain statistics", ex); + } + return (DailyStatistics[])days.ToArray(typeof(DailyStatistics)); + } + + #endregion + + #region Domains + + /// + /// Checks whether the specified domain exists + /// + /// Domain name + /// true if the specified domain exists, otherwise false + public bool DomainExists(string domainName) + { + try + { + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + DomainSettingsResult result = domains.GetDomainSettings(AdminUsername, AdminPassword, domainName); + return result.Result; + } + catch (Exception ex) + { + throw new Exception("Could not check whether mail domain exists", ex); + } + } + + public string[] GetDomains() + { + try + { + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + DomainListResult result = domains.GetAllDomains(AdminUsername, AdminPassword); + if (!result.Result) + throw new Exception(result.Message); + + return result.DomainNames; + } + catch (Exception ex) + { + throw new Exception("Could not get the list of mail domains", ex); + } + } + + public MailDomain GetDomain(string domainName) + { + try + { + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + DomainSettingsResult result = domains.GetDomainSettings(AdminUsername, AdminPassword, domainName); + if (!result.Result) + throw new Exception(result.Message); + + // fill domain properties + MailDomain domain = new MailDomain(); + domain.Name = domainName; + domain.Path = result.Path; + domain.ServerIP = result.ServerIP; + domain.ImapPort = result.ImapPort; + domain.SmtpPort = result.SmtpPort; + domain.PopPort = result.PopPort; + domain.MaxAliases = result.MaxAliases; + domain.MaxDomainAliases = result.MaxDomainAliases; + domain.MaxLists = result.MaxLists; + domain.MaxDomainSizeInMB = result.MaxDomainSizeInMB; + domain.MaxDomainUsers = result.MaxDomainUsers; + domain.MaxMailboxSizeInMB = result.MaxMailboxSizeInMB; + domain.MaxMessageSize = result.MaxMessageSize; + domain.MaxRecipients = result.MaxRecipients; + domain.RequireSmtpAuthentication = result.RequireSmtpAuthentication; + domain.ListCommandAddress = result.ListCommandAddress; + domain.ShowContentFilteringMenu = result.ShowContentFilteringMenu; + domain.ShowDomainAliasMenu = result.ShowDomainAliasMenu; + domain.ShowListMenu = result.ShowListMenu; + domain.ShowSpamMenu = result.ShowSpamMenu; + // get additional domain settings + string[] requestedSettings = new string[] + { + "catchall", + "enablepopretrieval", + "enablecatchalls", + "isenabled", + "ldapport", + "altsmtpport", + "sharedcalendar", + "sharedcontact", + "sharedfolder", + "sharednotes", + "sharedtasks", + "sharedgal", + "bypassforwardblacklist", + "showdomainreports", + "spamresponderoption", + "spamforwardoption", + "maxmessagesperhour", + "maxmessagesperhourenabled", + "maxsmtpoutbandwidthperhour", + "maxsmtpoutbandwidthperhourenabled", + "maxpopretrievalaccounts", + "maxbouncesreceivedperhour", + "maxbouncesreceivedperhourenabled", + "enableimapretrieval", + "enablemailsigning", + "enableemailreports", + "syncml" + }; + + SettingsRequestResult addResult = domains.GetRequestedDomainSettings(AdminUsername, AdminPassword, domainName, requestedSettings); + if (!addResult.Result) + throw new Exception(addResult.Message); + + FillMailDomainFields(domain, addResult); + + + // get catch-all address + if (!String.IsNullOrEmpty(domain.CatchAllAccount)) + { + // get catch-all group + string groupName = SYSTEM_CATCH_ALL + "@" + domain.Name; + if (GroupExists(groupName)) + { + // get the first member of this group + MailGroup group = GetGroup(groupName); + + if (group.Members.Length > 0) + { + domain.CatchAllAccount = GetAccountName(group.Members[0]); + } + } + } + + + svcServerAdmin serverAdmin = new svcServerAdmin(); + PrepareProxy(serverAdmin); + + EditionResult licenseType = serverAdmin.GetEdition(AdminUsername, AdminPassword); + + if (licenseType.Edition == "PRO") + { + domain[MailDomain.SMARTERMAIL_LICENSE_TYPE] = "PRO"; + } + if (licenseType.Edition == "ENT") + { + domain[MailDomain.SMARTERMAIL_LICENSE_TYPE] = "ENT"; + } + if (licenseType.Edition == "FREE") + { + domain[MailDomain.SMARTERMAIL_LICENSE_TYPE] = "FREE"; + } + + + return domain; + } + catch (Exception ex) + { + throw new Exception("Could not get mail domain", ex); + } + } + + public void CreateDomain(MailDomain domain) + { + try + { + + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + DomainSettingsResult defaultDomainSettings = domains.GetDomainDefaults(AdminUsername, AdminPassword); + + SettingsRequestResult defaultRequestedSettings = + domains.GetRequestedDomainDefaults(AdminUsername, AdminPassword, new string[] + { + "defaultaltsmtpport", + "defaultaltsmtpportenabled", + "defaultautoresponderrestriction", + "defaultbypassgreylisting", + "defaultenablecatchalls", + "defaultenabledomainkeys", + "defaultenableemailreports", + "defaultenablepopretrieval", + "defaultmaxmessagesperhour", + "defaultmaxmessagesperhourenabled", + "defaultmaxsmtpoutbandwidthperhour", + "defaultmaxsmtpoutbandwidthperhourenabled", + "defaultmaxbouncesreceivedperhour", + "defaultmaxbouncesreceivedperhourenabled", + "defaultmaxpopretrievalaccounts", + "defaultsharedcalendar", + "defaultsharedcontact", + "defaultsharedfolder", + "defaultsharedgal", + "defaultsharednotes", + "defaultsharedtasks", + "defaultshowcalendar", + "defaultshowcontacts", + "defaultshowcontentfilteringmenu", + "defaultshowdomainaliasmenu", + "defaultshowdomainreports", + "defaultshowlistmenu", + "defaultshownotes", + "defaultshowspammenu", + "defaultshowtasks", + "defaultshowuserreports", + "defaultskin", + "defaultspamresponderoption", + "defaultspamforwardoption" + }); + + string[] requestedDomainDefaults = defaultRequestedSettings.settingValues; + + //domain Path is taken from WebsitePanel Service settings + + GenericResult result = null; + + if (!InheritDomainDefaultLimits) + { + result = domains.AddDomain(AdminUsername, + AdminPassword, + domain.Name, + Path.Combine(DomainsPath, domain.Name), + SYSTEM_DOMAIN_ADMIN, // admin username + Guid.NewGuid().ToString("P"), // admin password + "Domain", // admin first name + "Administrator", // admin last name + ServerIP, + defaultDomainSettings.ImapPort, + defaultDomainSettings.PopPort, + defaultDomainSettings.SmtpPort, + domain.MaxAliases, + domain.MaxDomainSizeInMB, + domain.MaxDomainUsers, + domain.MaxMailboxSizeInMB, + domain.MaxMessageSize, + domain.MaxRecipients, + domain.MaxDomainAliases, + domain.MaxLists, + defaultDomainSettings.ShowDomainAliasMenu, + // ShowDomainAliasMenu + defaultDomainSettings.ShowContentFilteringMenu, + // ShowContentFilteringMenu + defaultDomainSettings.ShowSpamMenu, // ShowSpamMenu + defaultDomainSettings.ShowStatsMenu, // ShowStatsMenu + defaultDomainSettings.RequireSmtpAuthentication, + defaultDomainSettings.ShowListMenu, // ShowListMenu + defaultDomainSettings.ListCommandAddress); + } + else + { + result = domains.AddDomain(AdminUsername, AdminPassword, + domain.Name, + Path.Combine(DomainsPath, domain.Name), + SYSTEM_DOMAIN_ADMIN, // admin username + Guid.NewGuid().ToString("P"), // admin password + "Domain", // admin first name + "Administrator", // admin last name + ServerIP, + defaultDomainSettings.ImapPort, + defaultDomainSettings.PopPort, + defaultDomainSettings.SmtpPort, + defaultDomainSettings.MaxAliases, + defaultDomainSettings.MaxDomainSizeInMB, + defaultDomainSettings.MaxDomainUsers, + defaultDomainSettings.MaxMailboxSizeInMB, + defaultDomainSettings.MaxMessageSize, + defaultDomainSettings.MaxRecipients, + defaultDomainSettings.MaxDomainAliases, + defaultDomainSettings.MaxLists, + defaultDomainSettings.ShowDomainAliasMenu, // ShowDomainAliasMenu + defaultDomainSettings.ShowContentFilteringMenu, // ShowContentFilteringMenu + defaultDomainSettings.ShowSpamMenu, // ShowSpamMenu + defaultDomainSettings.ShowStatsMenu, // ShowStatsMenu + defaultDomainSettings.RequireSmtpAuthentication, + defaultDomainSettings.ShowListMenu, // ShowListMenu + defaultDomainSettings.ListCommandAddress); + } + if (!result.Result) + throw new Exception(result.Message); + + + // update additional settings + result = domains.SetRequestedDomainSettings(AdminUsername, AdminPassword, domain.Name, + SetMailDomainDefaultSettings(requestedDomainDefaults)); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + if (DomainExists(domain.Name)) + { + DeleteDomain(domain.Name); + } + Log.WriteError(ex); + throw new Exception("Could not create mail domain", ex); + } + } + + public void UpdateDomain(MailDomain domain) + { + try + { + // load original domain + MailDomain origDomain = GetDomain(domain.Name); + + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + GenericResult result = domains.UpdateDomain(AdminUsername, AdminPassword, + domain.Name, + origDomain.ServerIP, + domain.ImapPort, + domain.PopPort, + domain.SmtpPort, + domain.MaxAliases, + domain.MaxDomainSizeInMB, + domain.MaxDomainUsers, + domain.MaxMailboxSizeInMB, + domain.MaxMessageSize, + domain.MaxRecipients, + domain.MaxDomainAliases, + domain.MaxLists, + domain.ShowDomainAliasMenu, // ShowDomainAliasMenu + domain.ShowContentFilteringMenu, // ShowContentFilteringMenu + domain.ShowSpamMenu, // ShowSpamMenu + domain.ShowsStatsMenu, // this parameter is no longer used in SM5 + origDomain.RequireSmtpAuthentication, + domain.ShowListMenu, // Showlistmenu + origDomain.ListCommandAddress); + + if (!result.Result) + throw new Exception(result.Message); + + // update catch-all group + UpdateDomainCatchAllGroup(domain.Name, domain.CatchAllAccount); + + + // update additional settings + result = domains.SetRequestedDomainSettings(AdminUsername, AdminPassword, domain.Name, + new string[] { + "isenabled=" + domain.Enabled, + "catchall=" + (!String.IsNullOrEmpty(domain.CatchAllAccount) ? SYSTEM_CATCH_ALL : ""), + "altsmtpport=" + domain.SmtpPortAlt, + "ldapport=" + domain.LdapPort, + "sharedcalendar=" + domain.SharedCalendars, + "sharedcontact=" + domain.SharedContacts, + "sharedfolder=" + domain.SharedFolders, + "sharednotes=" + domain.SharedNotes, + "sharedtasks=" + domain.SharedTasks, + "sharedgal=" + domain.IsGlobalAddressList, + "enablecatchalls=" + domain[MailDomain.SMARTERMAIL5_CATCHALLS_ENABLED], + "bypassforwardblacklist=" + domain.BypassForwardBlackList, + "showdomainreports=" + domain[MailDomain.SMARTERMAIL5_SHOW_DOMAIN_REPORTS], + "maxmessagesperhour=" + domain[MailDomain.SMARTERMAIL5_MESSAGES_PER_HOUR], + "maxmessagesperhourenabled=" + domain[MailDomain.SMARTERMAIL5_MESSAGES_PER_HOUR_ENABLED], + "maxsmtpoutbandwidthperhour=" + domain[MailDomain.SMARTERMAIL5_BANDWIDTH_PER_HOUR], + "maxsmtpoutbandwidthperhourenabled=" + domain[MailDomain.SMARTERMAIL5_BANDWIDTH_PER_HOUR_ENABLED], + "enablepopretrieval=" + domain[MailDomain.SMARTERMAIL5_POP_RETREIVAL_ENABLED], + "maxpopretrievalaccounts=" + domain[MailDomain.SMARTERMAIL5_POP_RETREIVAL_ACCOUNTS], + "maxbouncesreceivedperhour=" + domain[MailDomain.SMARTERMAIL5_BOUNCES_PER_HOUR], + "maxbouncesreceivedperhourenabled=" + domain[MailDomain.SMARTERMAIL5_BOUNCES_PER_HOUR_ENABLED], + "enableimapretrieval=" + domain[MailDomain.SMARTERMAIL6_IMAP_RETREIVAL_ENABLED], + "enablemailsigning=" + domain[MailDomain.SMARTERMAIL6_MAIL_SIGNING_ENABLED], + "enableemailreports=" + domain[MailDomain.SMARTERMAIL6_EMAIL_REPORTS_ENABLED], + "syncml=" + domain[MailDomain.SMARTERMAIL6_SYNCML_ENABLED] + }); + + /* + + string[] requestedSettings = new string[] + { + "maxmessagesperhour", + "maxmessagesperhourenabled", + "maxsmtpoutbandwidthperhour", + "maxsmtpoutbandwidthperhourenabled" + }; + + SettingsRequestResult addResult = + domains.GetRequestedDomainSettings(AdminUsername, AdminPassword, domain.Name, requestedSettings); + */ + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not update mail domain", ex); + } + } + + public void DeleteDomain(string domainName) + { + try + { + svcDomainAdmin domains = new svcDomainAdmin(); + PrepareProxy(domains); + + GenericResult result = domains.DeleteDomain(AdminUsername, AdminPassword, + domainName, + true // delete files + ); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not delete mail domain", ex); + } + } + + public bool DomainAliasExists(string domainName, string aliasName) + { + try + { + string[] aliases = GetDomainAliases(domainName); + foreach (string alias in aliases) + { + if (String.Compare(alias, aliasName, true) == 0) + return true; + } + return false; + } + catch (Exception ex) + { + throw new Exception("Could not check whether mail domain alias exists", ex); + } + } + + public string[] GetDomainAliases(string domainName) + { + try + { + svcDomainAliasAdmin aliases = new svcDomainAliasAdmin(); + PrepareProxy(aliases); + + DomainAliasInfoListResult result = aliases.GetAliases(AdminUsername, AdminPassword, domainName); + + if (!result.Result) + throw new Exception(result.Message); + + return result.DomainAliasNames; + } + catch (Exception ex) + { + throw new Exception("Could not get the list of mail domain aliases", ex); + } + } + + public void AddDomainAlias(string domainName, string aliasName) + { + try + { + svcDomainAliasAdmin aliases = new svcDomainAliasAdmin(); + PrepareProxy(aliases); + + GenericResult result = aliases.AddDomainAliasWithoutMxCheck(AdminUsername, AdminPassword, + domainName, aliasName); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not add mail domain alias", ex); + } + } + + public void DeleteDomainAlias(string domainName, string aliasName) + { + try + { + svcDomainAliasAdmin aliases = new svcDomainAliasAdmin(); + PrepareProxy(aliases); + + GenericResult result = aliases.DeleteDomainAlias(AdminUsername, AdminPassword, + domainName, aliasName); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not delete mail domain alias", ex); + } + } + + private static string[] SetMailDomainDefaultSettings(string[] defaultSettings) + { + List settings = new List(); + + foreach (string pair in defaultSettings) + { + string[] parts = pair.Split('='); + switch (parts[0]) + { + case "defaultaltsmtpport": + settings.Add("altsmtpport=" + parts[1]); + break; + case "defaultaltsmtpportenabled": + settings.Add("altsmtpportenabled=" + parts[1]); + break; + case "defaultbypassgreylisting": + settings.Add("bypassgreylisting=" + parts[1]); + break; + case "defaultenablecatchalls": + if (String.Equals(parts[1], "Enabled")) + settings.Add("enablecatchalls=True"); + if (String.Equals(parts[1], "Disabled")) + settings.Add("enablecatchalls=False"); + break; + case "defaultenabledomainkeys": + settings.Add("enabledomainkeys=" + parts[1]); + break; + case "defaultenableemailreports": + settings.Add("enableemailreports=" + parts[1]); + break; + case "defaultenablepopretrieval": + settings.Add("enablepopretrieval=" + parts[1]); + break; + case "defaultautoresponderrestriction": + settings.Add("autoresponderrestriction=" + parts[1]); + break; + case "defaultmaxmessagesperhour": + settings.Add("maxmessagesperhour=" + parts[1]); + break; + case "defaultmaxmessagesperhourenabled": + settings.Add("maxmessagesperhourenabled=" + parts[1]); + break; + case "defaultmaxsmtpoutbandwidthperhour": + settings.Add("maxsmtpoutbandwidthperhour=" + parts[1]); + break; + case "defaultmaxsmtpoutbandwidthperhourenabled": + settings.Add("maxsmtpoutbandwidthperhourenabled=" + parts[1]); + break; + case "defaultmaxbouncesreceivedperhour": + settings.Add("maxbouncesreceivedperhour=" + parts[1]); + break; + case "defaultmaxbouncesreceivedperhourenabled": + settings.Add("maxbouncesreceivedperhourenabled=" + parts[1]); + break; + case "defaultsharedcalendar": + settings.Add("sharedcalendar=" + parts[1]); + break; + case "defaultsharedcontact": + settings.Add("sharedcontact=" + parts[1]); + break; + case "defaultsharedfolder": + settings.Add("sharedfolder=" + parts[1]); + break; + case "defaultsharedgal": + settings.Add("sharedgal=" + parts[1]); + break; + case "defaultsharednotes": + settings.Add("sharednotes=" + parts[1]); + break; + case "defaultsharedtasks": + settings.Add("sharedtasks=" + parts[1]); + break; + + case "defaultshowcalendar": + settings.Add("showcalendar=" + parts[1]); + break; + case "defaultshowcontacts": + settings.Add("showcontacts=" + parts[1]); + break; + case "defaultshowcontentfilteringmenu": + settings.Add("showcontentfilteringmenu=" + parts[1]); + break; + case "defaultshowdomainaliasmenu": + settings.Add("showdomainaliasmenu=" + parts[1]); + break; + case "defaultshowdomainreports": + settings.Add("showdomainreports=" + parts[1]); + break; + case "defaultshowlistmenu": + settings.Add("showlistmenu=" + parts[1]); + break; + case "defaultshownotes": + settings.Add("shownotes=" + parts[1]); + break; + case "defaultshowtasks": + settings.Add("showtasks=" + parts[1]); + break; + case "defaultshowuserreports": + settings.Add("showuserreports=" + parts[1]); + break; + case "defaultshowspammenu": + settings.Add("showspammenu=" + parts[1]); + break; + case "defaultspamresponderoption": + settings.Add("spamresponderoption=" + parts[1]); + break; + case "defaultspamforwardoption": + settings.Add("spamforwardoption=" + parts[1]); + break; + + // "defaultskin" + } + } + return settings.ToArray(); + } + + private static void FillMailDomainFields(MailDomain domain, SettingsRequestResult addResult) + { + foreach (string pair in addResult.settingValues) + { + string[] parts = pair.Split('='); + switch (parts[0]) + { + case "catchall": + domain.CatchAllAccount = parts[1]; + break; + case "enablecatchalls": + if (String.Equals(parts[1], "Enabled")) + domain[MailDomain.SMARTERMAIL5_CATCHALLS_ENABLED] = "True"; + if (String.Equals(parts[1], "Disabled")) + domain[MailDomain.SMARTERMAIL5_CATCHALLS_ENABLED] = "False"; + break; + case "enablepopretrieval": + domain[MailDomain.SMARTERMAIL5_POP_RETREIVAL_ENABLED] = parts[1]; + break; + case "isenabled": + domain.Enabled = Boolean.Parse(parts[1]); + break; + case "ldapport": + domain.LdapPort = int.Parse(parts[1]); + break; + case "altsmtpport": + domain.SmtpPortAlt = int.Parse(parts[1]); + break; + case "sharedcalendar": + domain.SharedCalendars = Boolean.Parse(parts[1]); + break; + case "sharedcontact": + domain.SharedContacts = Boolean.Parse(parts[1]); + break; + case "sharedfolder": + domain.SharedFolders = Boolean.Parse(parts[1]); + break; + case "sharednotes": + domain.SharedNotes = Boolean.Parse(parts[1]); + break; + case "sharedtasks": + domain.SharedTasks = Boolean.Parse(parts[1]); + break; + case "sharedgal": + domain.IsGlobalAddressList = Boolean.Parse(parts[1]); + break; + case "bypassforwardblacklist": + domain.BypassForwardBlackList = Boolean.Parse(parts[1]); + break; + case "showdomainreports": + domain[MailDomain.SMARTERMAIL5_SHOW_DOMAIN_REPORTS] = parts[1]; + break; + case "maxmessagesperhour": + domain[MailDomain.SMARTERMAIL5_MESSAGES_PER_HOUR] = parts[1]; + break; + case "maxmessagesperhourenabled": + domain[MailDomain.SMARTERMAIL5_MESSAGES_PER_HOUR_ENABLED] = parts[1]; + break; + case "maxsmtpoutbandwidthperhour": + domain[MailDomain.SMARTERMAIL5_BANDWIDTH_PER_HOUR] = parts[1]; + break; + case "maxsmtpoutbandwidthperhourenabled": + domain[MailDomain.SMARTERMAIL5_BANDWIDTH_PER_HOUR_ENABLED] = parts[1]; + break; + case "maxpopretrievalaccounts": + domain[MailDomain.SMARTERMAIL5_POP_RETREIVAL_ACCOUNTS] = parts[1]; + break; + case "maxbouncesreceivedperhour": + domain[MailDomain.SMARTERMAIL5_BOUNCES_PER_HOUR] = parts[1]; + break; + case "maxbouncesreceivedperhourenabled": + domain[MailDomain.SMARTERMAIL5_BOUNCES_PER_HOUR_ENABLED] = parts[1]; + break; + case "enableimapretrieval": + domain[MailDomain.SMARTERMAIL6_IMAP_RETREIVAL_ENABLED] = parts[1]; + break; + case "enablemailsigning": + domain[MailDomain.SMARTERMAIL6_MAIL_SIGNING_ENABLED] = parts[1]; + break; + case "enableemailreports": + domain[MailDomain.SMARTERMAIL6_EMAIL_REPORTS_ENABLED] = parts[1]; + break; + case "syncml": + domain[MailDomain.SMARTERMAIL6_SYNCML_ENABLED] = parts[1]; + break; + } + } + } + + + private void UpdateDomainCatchAllGroup(string domainName, string mailboxName) + { + // check if system catch all group exists + string groupName = SYSTEM_CATCH_ALL + "@" + domainName; + if (GroupExists(groupName)) + { + // delete group + DeleteGroup(groupName); + } + + if (!String.IsNullOrEmpty(mailboxName)) + { + // create catch-all group + MailGroup group = new MailGroup(); + group.Name = groupName; + group.Enabled = true; + group.Members = new string[] { mailboxName + "@" + domainName }; + + // create + CreateGroup(group); + } + } + + + #endregion + + #region Mail Accounts + + public bool AccountExists(string mailboxName) + { + try + { + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + UserInfoResult result = users.GetUser(AdminUsername, AdminPassword, mailboxName); + + return result.Result; + } + catch (Exception ex) + { + throw new Exception("Could not check whether mailbox exists", ex); + } + } + + public MailAccount[] GetAccounts(string domainName) + { + try + { + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + UserInfoListResult result = users.GetUsers(AdminUsername, AdminPassword, domainName); + + if (!result.Result) + throw new Exception(result.Message); + + List accounts = new List(); + + + foreach (UserInfo user in result.Users) + { + if (user.IsDomainAdmin && !ImportDomainAdmin) + continue; + + MailAccount account = new MailAccount(); + account.Name = user.UserName; + account.Password = user.Password; + accounts.Add(account); + } + return accounts.ToArray(); + } + catch (Exception ex) + { + throw new Exception("Could not get the list of domain mailboxes", ex); + } + } + + public MailAccount GetAccount(string mailboxName) + { + try + { + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + UserInfoResult result = users.GetUser(AdminUsername, AdminPassword, mailboxName); + + if (!result.Result) + throw new Exception(result.Message); + + MailAccount mailbox = new MailAccount(); + mailbox.Name = result.UserInfo.UserName; + mailbox.Password = result.UserInfo.Password; + mailbox.FirstName = result.UserInfo.FirstName; + mailbox.LastName = result.UserInfo.LastName; + mailbox.IsDomainAdmin = result.UserInfo.IsDomainAdmin; + mailbox.IsDomainAdminEnabled = EnableDomainAdministrators; + + // get additional settings + string[] requestedSettings = new string[] + { + "isenabled", + "maxsize", + "lockpassword", + "replytoaddress", + "signature", + "passwordlocked" + }; + + SettingsRequestResult addResult = users.GetRequestedUserSettings(AdminUsername, AdminPassword, + mailboxName, requestedSettings); + + if (!addResult.Result) + throw new Exception(addResult.Message); + + foreach (string pair in addResult.settingValues) + { + string[] parts = pair.Split('='); + if (parts[0] == "isenabled") mailbox.Enabled = Boolean.Parse(parts[1]); + else if (parts[0] == "maxsize") mailbox.MaxMailboxSize = Int32.Parse(parts[1]); + else if (parts[0] == "passwordlocked") mailbox.PasswordLocked = Boolean.Parse(parts[1]); + else if (parts[0] == "replytoaddress") mailbox.ReplyTo = parts[1]; + else if (parts[0] == "signature") mailbox.Signature = parts[1]; + } + + // get forwardings info + UserForwardingInfoResult forwResult = users.GetUserForwardingInfo(AdminUsername, AdminPassword, mailboxName); + + if (!forwResult.Result) + throw new Exception(forwResult.Message); + + string[] forwAddresses = forwResult.ForwardingAddress.Split(';', ','); + List listForAddresses = new List(); + foreach (string forwAddress in forwAddresses) + { + if (!String.IsNullOrEmpty(forwAddress.Trim())) + listForAddresses.Add(forwAddress.Trim()); + } + + mailbox.ForwardingAddresses = listForAddresses.ToArray(); + mailbox.DeleteOnForward = forwResult.DeleteOnForward; + + // get autoresponder info + UserAutoResponseResult respResult = users.GetUserAutoResponseInfo(AdminUsername, AdminPassword, mailboxName); + + if (!respResult.Result) + throw new Exception(respResult.Message); + + mailbox.ResponderEnabled = respResult.Enabled; + mailbox.ResponderSubject = respResult.Subject; + mailbox.ResponderMessage = respResult.Body; + + return mailbox; + } + catch (Exception ex) + { + throw new Exception("Could not get mailbox", ex); + } + } + + public void CreateAccount(MailAccount mailbox) + { + try + { + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + GenericResult result = users.AddUser(AdminUsername, AdminPassword, + mailbox.Name, + mailbox.Password, + GetDomainName(mailbox.Name), + mailbox.FirstName, + mailbox.LastName, + mailbox.IsDomainAdmin // domain admin is false + ); + + if (!result.Result) + throw new Exception(result.Message); + + // set forwarding settings + result = users.UpdateUserForwardingInfo(AdminUsername, AdminPassword, + mailbox.Name, mailbox.DeleteOnForward, + (mailbox.ForwardingAddresses != null ? String.Join(", ", mailbox.ForwardingAddresses) : "")); + + if (!result.Result) + throw new Exception(result.Message); + + // set additional settings + result = users.SetRequestedUserSettings(AdminUsername, AdminPassword, mailbox.Name, mailbox.PrepareSetRequestedUserSettingsWebMethodParams()); + + if (!result.Result) + throw new Exception(result.Message); + + // set autoresponder settings + result = users.UpdateUserAutoResponseInfo(AdminUsername, AdminPassword, + mailbox.Name, + mailbox.ResponderEnabled, + (mailbox.ResponderSubject != null ? mailbox.ResponderSubject : ""), + (mailbox.ResponderMessage != null ? mailbox.ResponderMessage : "")); + + if (!result.Result) + throw new Exception(result.Message); + + } + catch (Exception ex) + { + if (AccountExists(mailbox.Name)) + { + DeleteAccount(mailbox.Name); + } + Log.WriteError(ex); + throw new Exception("Could not create mailbox", ex); + } + } + + public void UpdateAccount(MailAccount mailbox) + { + + try + { + //get original account + MailAccount account = GetAccount(mailbox.Name); + + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + string strPassword = mailbox.Password; + + //Don't change password. Get it from mail server. + if (!mailbox.ChangePassword) + { + strPassword = account.Password; + } + + GenericResult result = users.UpdateUser( + AdminUsername, AdminPassword, mailbox.Name, strPassword, mailbox.FirstName, mailbox.LastName, mailbox.IsDomainAdmin); + + if (!result.Result) + throw new Exception(result.Message); + + // set forwarding settings + result = users.UpdateUserForwardingInfo(AdminUsername, AdminPassword, + mailbox.Name, mailbox.DeleteOnForward, + (mailbox.ForwardingAddresses != null ? String.Join(", ", mailbox.ForwardingAddresses) : "")); + + if (!result.Result) + throw new Exception(result.Message); + + // Set additional settings + result = users.SetRequestedUserSettings(AdminUsername, AdminPassword, mailbox.Name, mailbox.PrepareSetRequestedUserSettingsWebMethodParams()); + + if (!result.Result) + throw new Exception(result.Message); + + // set autoresponder settings + result = users.UpdateUserAutoResponseInfo(AdminUsername, AdminPassword, + mailbox.Name, + mailbox.ResponderEnabled, + (mailbox.ResponderSubject != null ? mailbox.ResponderSubject : ""), + (mailbox.ResponderMessage != null ? mailbox.ResponderMessage : "")); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not update mailbox", ex); + } + + } + + public void DeleteAccount(string mailboxName) + { + try + { + svcUserAdmin users = new svcUserAdmin(); + PrepareProxy(users); + + GenericResult result = users.DeleteUser(AdminUsername, AdminPassword, + mailboxName, GetDomainName(mailboxName)); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not delete mailbox", ex); + } + } + + #endregion + + #region Mail Aliases + + public bool MailAliasExists(string mailAliasName) + { + try + { + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + AliasInfoResult result = aliases.GetAlias(AdminUsername, AdminPassword, GetDomainName(mailAliasName), mailAliasName); + + if ((!result.Result || (result.AliasInfo.Name.Equals("Empty")) && (result.AliasInfo.Addresses.Length == 0))) + return false; + + return true; + } + catch (Exception ex) + { + throw new Exception("Could not check whether mail alias exists", ex); + } + } + + public MailAlias[] GetMailAliases(string domainName) + { + try + { + + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + AliasInfoListResult result = aliases.GetAliases(AdminUsername, AdminPassword, domainName); + + if (!result.Result) + throw new Exception(result.Message); + + List aliasesList = new List(); + + + foreach (AliasInfo alias in result.AliasInfos) + { + if (alias.Addresses.Length == 1) + { + MailAlias mailAlias = new MailAlias(); + mailAlias.Name = alias.Name + "@" + domainName; + mailAlias.ForwardTo = alias.Addresses[0]; + aliasesList.Add(mailAlias); + } + } + return aliasesList.ToArray(); + } + catch (Exception ex) + { + throw new Exception("Could not get the list of mail aliases", ex); + } + + + } + + public MailAlias GetMailAlias(string mailAliasName) + { + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + + MailAlias alias = new MailAlias(); + MailAlias newAlias = new MailAlias(); + + //convert old alliases created as mailboxes + if (!MailAliasExists(mailAliasName)) + { + MailAccount account = GetAccount(mailAliasName); + newAlias.Name = account.Name; + if ((account.ForwardingAddresses != null) && (account.ForwardingAddresses.Length > 0)) + { + newAlias.ForwardTo = account.ForwardingAddresses[0]; + } + else + { + newAlias.ForwardTo = string.Empty; + } + DeleteAccount(mailAliasName); + CreateMailAlias(newAlias); + return newAlias; + } + + AliasInfoResult result = aliases.GetAlias(AdminUsername, AdminPassword, GetDomainName(mailAliasName), mailAliasName); + alias.Name = result.AliasInfo.Name; + if ((result.AliasInfo.Addresses != null) && (result.AliasInfo.Addresses.Length > 0)) + { + alias.ForwardTo = result.AliasInfo.Addresses[0]; + } + else + { + alias.ForwardTo = "empty@email.com"; + } + return alias; + } + + public void CreateMailAlias(MailAlias mailAlias) + { + try + { + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + GenericResult result = aliases.AddAlias(AdminUsername, AdminPassword, + GetDomainName(mailAlias.Name), mailAlias.Name, + new string[] { mailAlias.ForwardTo }); + + + if (!result.Result) + throw new Exception(result.Message); + } + + catch (Exception ex) + { + if (MailAliasExists(mailAlias.Name)) + { + DeleteMailAlias(mailAlias.Name); + } + Log.WriteError(ex); + throw new Exception("Could not create mail alias", ex); + + } + + } + + public void UpdateMailAlias(MailAlias mailAlias) + { + try + { + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + + GenericResult result = aliases.UpdateAlias(AdminUsername, AdminPassword, GetDomainName(mailAlias.Name), + mailAlias.Name, + new string[] { mailAlias.ForwardTo }); + + if (!result.Result) + throw new Exception(result.Message); + + } + catch (Exception ex) + { + throw new Exception("Could not update mailAlias", ex); + } + + } + + public void DeleteMailAlias(string mailAliasName) + { + try + { + svcAliasAdmin aliases = new svcAliasAdmin(); + PrepareProxy(aliases); + + GenericResult result = aliases.DeleteAlias(AdminUsername, AdminPassword, GetDomainName(mailAliasName), + mailAliasName); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not delete mailAlias", ex); + } + } + #endregion + + #region Groups + + public bool GroupExists(string groupName) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + AliasInfoResult result = svcGroups.GetAlias(AdminUsername, AdminPassword, + GetDomainName(groupName), groupName); + + return (result.Result + && result.AliasInfo.Name != "Empty"); + } + catch (Exception ex) + { + throw new Exception("Could not check whether mail domain group exists", ex); + } + } + + public MailGroup[] GetGroups(string domainName) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + AliasInfoListResult result = svcGroups.GetAliases(AdminUsername, AdminPassword, domainName); + + if (!result.Result) + throw new Exception(result.Message); + + + List groups = new List(); + + foreach (AliasInfo alias in result.AliasInfos) + { + //group - alias with more than one forwarding address + if (alias.Addresses.Length > 1) + { + MailGroup mailGroup = new MailGroup(); + mailGroup.Name = alias.Name + "@" + domainName; + mailGroup.Members = alias.Addresses; + groups.Add(mailGroup); + } + } + + return groups.ToArray(); + } + catch (Exception ex) + { + throw new Exception("Could not get the list of mail domain groups", ex); + } + } + + public MailGroup GetGroup(string groupName) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + AliasInfoResult result = svcGroups.GetAlias(AdminUsername, AdminPassword, + GetDomainName(groupName), groupName); + + if (!result.Result) + throw new Exception(result.Message); + + MailGroup group = new MailGroup(); + group.Name = groupName; + group.Members = result.AliasInfo.Addresses; + group.Enabled = true; // by default + return group; + } + catch (Exception ex) + { + throw new Exception("Could not get mail domain group", ex); + } + } + + public void CreateGroup(MailGroup group) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + GenericResult result = svcGroups.AddAlias(AdminUsername, AdminPassword, + GetDomainName(group.Name), group.Name, group.Members); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not create mail domain group", ex); + } + } + + public void UpdateGroup(MailGroup group) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + GenericResult result = svcGroups.UpdateAlias(AdminUsername, AdminPassword, + GetDomainName(group.Name), group.Name, group.Members); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not update mail domain group", ex); + } + } + + public void DeleteGroup(string groupName) + { + try + { + svcAliasAdmin svcGroups = new svcAliasAdmin(); + PrepareProxy(svcGroups); + + GenericResult result = svcGroups.DeleteAlias(AdminUsername, AdminPassword, + GetDomainName(groupName), groupName); + + if (!result.Result) + throw new Exception(result.Message); + } + catch (Exception ex) + { + throw new Exception("Could not delete mail domain group", ex); + } + } + + #endregion + + #region Lists + + public bool ListExists(string listName) + { + bool exists = false; + + try + { + string domain = GetDomainName(listName); + string account = GetAccountName(listName); + + svcMailListAdmin lists = new svcMailListAdmin(); + PrepareProxy(lists); + + MailingListResult result = lists.GetMailingListsByDomain(AdminUsername, AdminPassword, domain); + + if (result.Result) + { + foreach (string member in result.listNames) + { + if (string.Compare(member, listName, true) == 0) + { + exists = true; + break; + } + } + } + } + catch (Exception ex) + { + throw new Exception("Couldn't obtain mail list.", ex); + } + + return exists; + } + + public MailList[] GetLists(string domainName) + { + try + { + svcMailListAdmin svcLists = new svcMailListAdmin(); + PrepareProxy(svcLists); + + MailingListResult mResult = svcLists.GetMailingListsByDomain( + AdminUsername, + AdminPassword, + domainName + ); + + if (!mResult.Result) + throw new Exception(mResult.Message); + + List mailLists = new List(); + foreach (string listName in mResult.listNames) + { + SettingsRequestResult sResult = svcLists.GetRequestedListSettings( + AdminUsername, + AdminPassword, + domainName, + listName, + smListSettings + ); + + if (!sResult.Result) + throw new Exception(sResult.Message); + + SubscriberListResult rResult = svcLists.GetSubscriberList( + AdminUsername, + AdminPassword, + domainName, + listName + ); + + if (!rResult.Result) + throw new Exception(rResult.Message); + + MailList list = new MailList(); + list.Name = string.Concat(listName, "@", domainName); + SetMailListSettings(list, sResult.settingValues); + SetMailListMembers(list, rResult.Subscribers); + mailLists.Add(list); + } + + return mailLists.ToArray(); + } + catch (Exception ex) + { + throw new Exception("Couldn't obtain domain mail lists.", ex); + } + } + + public MailList GetList(string listName) + { + try + { + string domain = GetDomainName(listName); + string account = GetAccountName(listName); + + svcMailListAdmin svcLists = new svcMailListAdmin(); + PrepareProxy(svcLists); + + SettingsRequestResult sResult = svcLists.GetRequestedListSettings( + AdminUsername, + AdminPassword, + domain, + account, + smListSettings + ); + + if (!sResult.Result) + throw new Exception(sResult.Message); + + SubscriberListResult mResult = svcLists.GetSubscriberList( + AdminUsername, + AdminPassword, + domain, + account + ); + + if (!mResult.Result) + throw new Exception(mResult.Message); + + MailList list = new MailList(); + list.Name = listName; + + SetMailListSettings(list, sResult.settingValues); + SetMailListMembers(list, mResult.Subscribers); + + return list; + } + catch (Exception ex) + { + throw new Exception("Couldn't obtain mail list.", ex); + } + } + + protected void SetMailListMembers(MailList list, string[] subscribers) + { + List members = new List(); + + foreach (string subscriber in subscribers) + members.Add(subscriber); + + list.Members = members.ToArray(); + } + + private void SetMailListSettings(MailList list, string[] smSettings) + { + foreach (string setting in smSettings) + { + string[] bunch = setting.Split(new char[] { '=' }); + + switch (bunch[0]) + { + case "description": + list.Description = bunch[1]; + break; + case "disabled": + list.Enabled = !Convert.ToBoolean(bunch[1]); + break; + case "moderator": + list.ModeratorAddress = bunch[1]; + list.Moderated = !string.IsNullOrEmpty(bunch[1]); + break; + case "password": + list.Password = bunch[1]; + break; + case "requirepassword": + list.RequirePassword = Convert.ToBoolean(bunch[1]); + break; + case "whocanpost": + if (string.Compare(bunch[1], "anyone", true) == 0) + list.PostingMode = PostingMode.AnyoneCanPost; + else if (string.Compare(bunch[1], "moderator", true) == 0) + list.PostingMode = PostingMode.ModeratorCanPost; + else + list.PostingMode = PostingMode.MembersCanPost; + break; + case "prependsubject": + list.EnableSubjectPrefix = Convert.ToBoolean(bunch[1]); + break; + case "maxmessagesize": + list.MaxMessageSize = Convert.ToInt32(bunch[1]); + break; + case "maxrecipients": + list.MaxRecipientsPerMessage = Convert.ToInt32(bunch[1]); + break; + case "replytolist": + list.ReplyToMode = string.Compare(bunch[1], "true", true) == 0 ? ReplyTo.RepliesToList : ReplyTo.RepliesToSender; + break; + case "subject": + list.SubjectPrefix = bunch[1]; + break; + case "listtoaddress": + if (string.Compare(bunch[1], "DEFAULT", true) == 0) + list.ListToAddress = "DEFAULT"; + else if (string.Compare(bunch[1], "LISTADDRESS", true) == 0) + list.ListToAddress = "LISTADDRESS"; + else if (string.Compare(bunch[1], "SUBSCRIBERADDRESS", true) == 0) + list.ListToAddress = "SUBSCRIBERADDRESS"; + else + list.ListToAddress = bunch[1]; + break; + case "listfromaddress": + if (string.Compare(bunch[1], "LISTADDRESS", true) == 0) + list.ListFromAddress = "LISTADDRESS"; + else list.ListFromAddress = string.Compare(bunch[1], "POSTERADDRESS", true) == 0 ? "POSTERADDRESS" : bunch[1]; + break; + case "listreplytoaddress": + if (string.Compare(bunch[1], "LISTADDRESS", true) == 0) + list.ListReplyToAddress = "LISTADDRESS"; + else list.ListReplyToAddress = string.Compare(bunch[1], "POSTERADDRESS", true) == 0 ? "POSTERADDRESS" : bunch[1]; + break; + case "digestmode": + list.DigestMode = Convert.ToBoolean(bunch[1]); + break; + case "sendsubscribe": + list.SendSubscribe = Convert.ToBoolean(bunch[1]); + break; + case "sendunsubscribe": + list.SendUnsubscribe = Convert.ToBoolean(bunch[1]); + break; + case "allowunsubscribe": + list.AllowUnsubscribe = Convert.ToBoolean(bunch[1]); + break; + case "disablelistcommand": + list.DisableListcommand = Convert.ToBoolean(bunch[1]); + break; + case "disablesubscribecommand": + list.DisableSubscribecommand = Convert.ToBoolean(bunch[1]); + break; + + } + } + } + + public void CreateList(MailList list) + { + try + { + string domain = GetDomainName(list.Name); + string account = GetAccountName(list.Name); + + svcMailListAdmin lists = new svcMailListAdmin(); + PrepareProxy(lists); + + GenericResult result = lists.AddList(AdminUsername, AdminPassword, + domain, + account, + list.ModeratorAddress, + list.Description + ); + + if (!result.Result) + throw new Exception(result.Message); + + List settings = new List(); + settings.Add(string.Concat("description=", list.Description)); + settings.Add(string.Concat("disabled=", !list.Enabled)); + settings.Add(string.Concat("moderator=", list.ModeratorAddress)); + settings.Add(string.Concat("password=", list.Password)); + settings.Add(string.Concat("requirepassword=", list.RequirePassword)); + + switch (list.PostingMode) + { + case PostingMode.AnyoneCanPost: + settings.Add("whocanpost=anyone"); + break; + case PostingMode.MembersCanPost: + settings.Add("whocanpost=subscribersonly"); + break; + case PostingMode.ModeratorCanPost: + settings.Add("whocanpost=moderator"); + break; + } + + settings.Add(string.Concat("prependsubject=", list.EnableSubjectPrefix)); + settings.Add(string.Concat("maxmessagesize=", list.MaxMessageSize)); + //settings.Add(string.Concat("maxrecipients=", list.MaxRecipientsPerMessage)); + settings.Add(string.Concat("subject=", list.SubjectPrefix)); + + switch (list.ReplyToMode) + { + case ReplyTo.RepliesToList: + settings.Add("replytolist=true"); + break; + } + + //settings.Add(string.Concat("listtoaddress=", list.ListToAddress)); + //settings.Add(string.Concat("listfromaddress=", list.ListFromAddress)); + //settings.Add(string.Concat("listreplytoaddress=", list.ListReplyToAddress)); + settings.Add(string.Concat("digestmode=", list.DigestMode)); + settings.Add(string.Concat("sendsubscribe=", list.SendSubscribe)); + settings.Add(string.Concat("sendunsubscribe=", list.SendUnsubscribe)); + settings.Add(string.Concat("allowunsubscribe=", list.AllowUnsubscribe)); + settings.Add(string.Concat("disablelistcommand=", list.DisableListcommand)); + settings.Add(string.Concat("disablesubscribecommand=", list.DisableSubscribecommand)); + + result = lists.SetRequestedListSettings(AdminUsername, AdminPassword, + domain, + list.Name, + settings.ToArray() + ); + + if (!result.Result) + throw new Exception(result.Message); + + if (list.Members.Length > 0) + { + result = lists.SetSubscriberList(AdminUsername, AdminPassword, + domain, + list.Name, + list.Members + ); + + if (!result.Result) + throw new Exception(result.Message); + } + } + catch (Exception ex) + { + if (ListExists(list.Name)) + { + DeleteList(list.Name); + } + Log.WriteError(ex); + throw new Exception("Couldn't create mail list.", ex); + } + } + + public void UpdateList(MailList list) + { + try + { + string domain = GetDomainName(list.Name); + string account = GetAccountName(list.Name); + + svcMailListAdmin lists = new svcMailListAdmin(); + PrepareProxy(lists); + + List settings = new List(); + settings.Add(string.Concat("description=", list.Description)); + settings.Add(string.Concat("disabled=", !list.Enabled)); + settings.Add(string.Concat("moderator=", list.ModeratorAddress)); + settings.Add(string.Concat("password=", list.Password)); + settings.Add(string.Concat("requirepassword=", list.RequirePassword)); + + switch (list.PostingMode) + { + case PostingMode.AnyoneCanPost: + settings.Add("whocanpost=anyone"); + break; + case PostingMode.MembersCanPost: + settings.Add("whocanpost=subscribersonly"); + break; + case PostingMode.ModeratorCanPost: + settings.Add("whocanpost=moderatoronly"); + break; + } + + settings.Add(string.Concat("prependsubject=", list.EnableSubjectPrefix)); + settings.Add(string.Concat("maxmessagesize=", list.MaxMessageSize)); + //settings.Add(string.Concat("maxrecipients=", list.MaxRecipientsPerMessage)); + settings.Add(string.Concat("subject=", list.SubjectPrefix)); + + switch (list.ReplyToMode) + { + case ReplyTo.RepliesToList: + settings.Add("replytolist=true"); + break; + case ReplyTo.RepliesToSender: + settings.Add("replytolist=false"); + break; + } + + //settings.Add(string.Concat("listtoaddress=", list.ListToAddress)); + //settings.Add(string.Concat("listfromaddress=", list.ListFromAddress)); + //settings.Add(string.Concat("listreplytoaddress=", list.ListReplyToAddress)); + settings.Add(string.Concat("digestmode=", list.DigestMode)); + settings.Add(string.Concat("sendsubscribe=", list.SendSubscribe)); + settings.Add(string.Concat("sendunsubscribe=", list.SendUnsubscribe)); + settings.Add(string.Concat("allowunsubscribe=", list.AllowUnsubscribe)); + settings.Add(string.Concat("disablelistcommand=", list.DisableListcommand)); + settings.Add(string.Concat("disablesubscribecommand=", list.DisableSubscribecommand)); + + Log.WriteWarning(string.Join(" , ", settings.ToArray())); + + GenericResult result = lists.SetRequestedListSettings(AdminUsername, AdminPassword, + domain, + list.Name, + settings.ToArray() + ); + + if (!result.Result) + throw new Exception(result.Message); + + SubscriberListResult subsribersResult = lists.GetSubscriberList(AdminUsername, AdminPassword, domain, account); + + foreach (string member in subsribersResult.Subscribers) + { + GenericResult memberResult = lists.RemoveSubscriber(AdminUsername, AdminPassword, domain, account, member); + if (!memberResult.Result) + { + throw new Exception(memberResult.Message); + } + } + + if (list.Members.Length > 0) + { + result = lists.SetSubscriberList(AdminUsername, AdminPassword, + domain, + list.Name, + list.Members + ); + + if (!result.Result) + throw new Exception(result.Message); + } + } + catch (Exception ex) + { + throw new Exception("Couldn't update mail list.", ex); + } + } + + /// + /// Deletes specified mail list. + /// + /// Mail list name. + public void DeleteList(string listName) + { + try + { + svcMailListAdmin svcLists = new svcMailListAdmin(); + PrepareProxy(svcLists); + + string account = GetAccountName(listName); + string domain = GetDomainName(listName); + + GenericResult Result = svcLists.DeleteList( + AdminUsername, + AdminPassword, + domain, + listName + ); + + if (!Result.Result) + throw new Exception(Result.Message); + } + catch (Exception ex) + { + throw new Exception("Couldn't delete a mail list.", ex); + } + } + + #endregion + + private void PrepareProxy(SoapHttpClientProtocol proxy) + { + string smarterUrl = ServiceUrl; + + if (String.IsNullOrEmpty(smarterUrl)) + smarterUrl = "http://localhost:9998/services/"; + + int idx = proxy.Url.LastIndexOf("/"); + + // strip the last slash if any + if (smarterUrl[smarterUrl.Length - 1] == '/') + smarterUrl = smarterUrl.Substring(0, smarterUrl.Length - 1); + + proxy.Url = smarterUrl + proxy.Url.Substring(idx); + } + + protected string GetDomainName(string email) + { + return email.Substring(email.IndexOf('@') + 1); + } + + protected string GetAccountName(string email) + { + return email.Substring(0, email.IndexOf('@')); + } + + public override bool IsInstalled() + { + string productName = null; + string productVersion = null; + + RegistryKey HKLM = Registry.LocalMachine; + + RegistryKey key = HKLM.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"); + String[] names = null; + + if (key != null) + { + names = key.GetSubKeyNames(); + + foreach (string s in names) + { + RegistryKey subkey = HKLM.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\" + s); + if (subkey != null) + if (!String.IsNullOrEmpty((string)subkey.GetValue("DisplayName"))) + { + productName = (string)subkey.GetValue("DisplayName"); + } + if (productName != null && productName.Equals("SmarterMail")) + { + if (subkey != null) + productVersion = (string)subkey.GetValue("DisplayVersion"); + break; + } + } + + if (!String.IsNullOrEmpty(productVersion)) + { + int version = 0; + string[] split = productVersion.Split(new[] { '.' }); + + if (int.TryParse(split[0], out version)) + { + if (version >= 10) return true; + } + else + return split[0].Equals("10"); + } + } + + //checking x64 platform + key = HKLM.OpenSubKey(@"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall"); + + if (key == null) + { + return false; + } + + names = key.GetSubKeyNames(); + + foreach (string s in names) + { + RegistryKey subkey = HKLM.OpenSubKey(@"SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\" + s); + if (subkey != null) + if (!String.IsNullOrEmpty((string)subkey.GetValue("DisplayName"))) + { + productName = (string)subkey.GetValue("DisplayName"); + } + if (productName != null) + if (productName.Equals("SmarterMail")) + { + if (subkey != null) productVersion = (string)subkey.GetValue("DisplayVersion"); + break; + } + } + + if (!String.IsNullOrEmpty(productVersion)) + { + int version = 0; + string[] split = productVersion.Split(new[] { '.' }); + + if (int.TryParse(split[0], out version)) + { + if (version >= 10) return true; + } + else + return split[0].Equals("10"); + } + + return false; + } + } +} \ No newline at end of file diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10Proxies.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10Proxies.cs new file mode 100644 index 00000000..c92f7912 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/SmarterMail10Proxies.cs @@ -0,0 +1,22544 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.1 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +// +// This source code was auto-generated by wsdl, Version=4.0.30319.1. +// +namespace WebsitePanel.Mail.SM10 +{ + using System; + using System.Diagnostics; + using System.Xml.Serialization; + using System.ComponentModel; + using System.Web.Services.Protocols; + using System.Web.Services; + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcDomainAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcDomainAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback AddDomainOperationCompleted; + + private System.Threading.SendOrPostCallback AddDomainExOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateDomainNameAndPathOperationCompleted; + + private System.Threading.SendOrPostCallback GenerateDomainKeysCertOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainKeysCertOperationCompleted; + + private System.Threading.SendOrPostCallback RenameDomainOperationCompleted; + + private System.Threading.SendOrPostCallback ReloadDomainOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateDomainOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedDomainDefaultsOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedDomainSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback SetRequestedDomainDefaultsOperationCompleted; + + private System.Threading.SendOrPostCallback SetRequestedDomainSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteDomainOperationCompleted; + + private System.Threading.SendOrPostCallback GetAllDomainsOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainCountsOperationCompleted; + + private System.Threading.SendOrPostCallback GetAllDomainAliasesOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainUsersOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainStatisticsOperationCompleted; + + private System.Threading.SendOrPostCallback GetAllDomainStatisticsOperationCompleted; + + private System.Threading.SendOrPostCallback GetPrimaryDomainAdminOperationCompleted; + + private System.Threading.SendOrPostCallback SetPrimaryDomainAdminOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainDefaultsOperationCompleted; + + private System.Threading.SendOrPostCallback DisableDomainOperationCompleted; + + private System.Threading.SendOrPostCallback EnableDomainOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainInfoOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainForwardingOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainForwardingBlockOperationCompleted; + + private System.Threading.SendOrPostCallback GetDomainForwardingBlockByTargetAddressOperationCompleted; + + private System.Threading.SendOrPostCallback SetDomainForwardingBlockOperationCompleted; + + private System.Threading.SendOrPostCallback SetDomainForwardingBlockByTargetAddressOperationCompleted; + + private System.Threading.SendOrPostCallback AddDomainForwardingBlockOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteDomainForwardingBlockOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteDomainForwardBlockByTargetAddressOperationCompleted; + + private System.Threading.SendOrPostCallback SetDomainArchiveRuleOperationCompleted; + + /// + public svcDomainAdmin() + { + this.Url = "http://127.0.0.1:9998/Services/svcDomainAdmin.asmx"; + } + + /// + public event AddDomainCompletedEventHandler AddDomainCompleted; + + /// + public event AddDomainExCompletedEventHandler AddDomainExCompleted; + + /// + public event UpdateDomainNameAndPathCompletedEventHandler UpdateDomainNameAndPathCompleted; + + /// + public event GenerateDomainKeysCertCompletedEventHandler GenerateDomainKeysCertCompleted; + + /// + public event GetDomainKeysCertCompletedEventHandler GetDomainKeysCertCompleted; + + /// + public event RenameDomainCompletedEventHandler RenameDomainCompleted; + + /// + public event ReloadDomainCompletedEventHandler ReloadDomainCompleted; + + /// + public event UpdateDomainCompletedEventHandler UpdateDomainCompleted; + + /// + public event GetRequestedDomainDefaultsCompletedEventHandler GetRequestedDomainDefaultsCompleted; + + /// + public event GetRequestedDomainSettingsCompletedEventHandler GetRequestedDomainSettingsCompleted; + + /// + public event SetRequestedDomainDefaultsCompletedEventHandler SetRequestedDomainDefaultsCompleted; + + /// + public event SetRequestedDomainSettingsCompletedEventHandler SetRequestedDomainSettingsCompleted; + + /// + public event DeleteDomainCompletedEventHandler DeleteDomainCompleted; + + /// + public event GetAllDomainsCompletedEventHandler GetAllDomainsCompleted; + + /// + public event GetDomainCountsCompletedEventHandler GetDomainCountsCompleted; + + /// + public event GetAllDomainAliasesCompletedEventHandler GetAllDomainAliasesCompleted; + + /// + public event GetDomainUsersCompletedEventHandler GetDomainUsersCompleted; + + /// + public event GetDomainStatisticsCompletedEventHandler GetDomainStatisticsCompleted; + + /// + public event GetAllDomainStatisticsCompletedEventHandler GetAllDomainStatisticsCompleted; + + /// + public event GetPrimaryDomainAdminCompletedEventHandler GetPrimaryDomainAdminCompleted; + + /// + public event SetPrimaryDomainAdminCompletedEventHandler SetPrimaryDomainAdminCompleted; + + /// + public event GetDomainDefaultsCompletedEventHandler GetDomainDefaultsCompleted; + + /// + public event DisableDomainCompletedEventHandler DisableDomainCompleted; + + /// + public event EnableDomainCompletedEventHandler EnableDomainCompleted; + + /// + public event GetDomainInfoCompletedEventHandler GetDomainInfoCompleted; + + /// + public event GetDomainSettingsCompletedEventHandler GetDomainSettingsCompleted; + + /// + public event GetDomainForwardingCompletedEventHandler GetDomainForwardingCompleted; + + /// + public event GetDomainForwardingBlockCompletedEventHandler GetDomainForwardingBlockCompleted; + + /// + public event GetDomainForwardingBlockByTargetAddressCompletedEventHandler GetDomainForwardingBlockByTargetAddressCompleted; + + /// + public event SetDomainForwardingBlockCompletedEventHandler SetDomainForwardingBlockCompleted; + + /// + public event SetDomainForwardingBlockByTargetAddressCompletedEventHandler SetDomainForwardingBlockByTargetAddressCompleted; + + /// + public event AddDomainForwardingBlockCompletedEventHandler AddDomainForwardingBlockCompleted; + + /// + public event DeleteDomainForwardingBlockCompletedEventHandler DeleteDomainForwardingBlockCompleted; + + /// + public event DeleteDomainForwardBlockByTargetAddressCompletedEventHandler DeleteDomainForwardBlockByTargetAddressCompleted; + + /// + public event SetDomainArchiveRuleCompletedEventHandler SetDomainArchiveRuleCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDomain( + string AuthUserName, + string AuthPassword, + string DomainName, + string Path, + string PrimaryDomainAdminUserName, + string PrimaryDomainAdminPassword, + string PrimaryDomainAdminFirstName, + string PrimaryDomainAdminLastName, + string IP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress) + { + object[] results = this.Invoke("AddDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDomain( + string AuthUserName, + string AuthPassword, + string DomainName, + string Path, + string PrimaryDomainAdminUserName, + string PrimaryDomainAdminPassword, + string PrimaryDomainAdminFirstName, + string PrimaryDomainAdminLastName, + string IP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress, + System.AsyncCallback callback, + object asyncState) + { + return this.BeginInvoke("AddDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}, callback, asyncState); + } + + /// + public GenericResult EndAddDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDomainAsync( + string AuthUserName, + string AuthPassword, + string DomainName, + string Path, + string PrimaryDomainAdminUserName, + string PrimaryDomainAdminPassword, + string PrimaryDomainAdminFirstName, + string PrimaryDomainAdminLastName, + string IP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress) + { + this.AddDomainAsync(AuthUserName, AuthPassword, DomainName, Path, PrimaryDomainAdminUserName, PrimaryDomainAdminPassword, PrimaryDomainAdminFirstName, PrimaryDomainAdminLastName, IP, ImapPort, PopPort, SmtpPort, MaxAliases, MaxDomainSizeInMB, MaxDomainUsers, MaxMailboxSizeInMB, MaxMessageSize, MaxRecipients, MaxDomainAliases, MaxLists, ShowDomainAliasMenu, ShowContentFilteringMenu, ShowSpamMenu, ShowStatsMenu, RequireSmtpAuthentication, ShowListMenu, ListCommandAddress, null); + } + + /// + public void AddDomainAsync( + string AuthUserName, + string AuthPassword, + string DomainName, + string Path, + string PrimaryDomainAdminUserName, + string PrimaryDomainAdminPassword, + string PrimaryDomainAdminFirstName, + string PrimaryDomainAdminLastName, + string IP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress, + object userState) + { + if ((this.AddDomainOperationCompleted == null)) + { + this.AddDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDomainOperationCompleted); + } + this.InvokeAsync("AddDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}, this.AddDomainOperationCompleted, userState); + } + + private void OnAddDomainOperationCompleted(object arg) + { + if ((this.AddDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDomainCompleted(this, new AddDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDomainEx", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDomainEx(string AuthUserName, string AuthPassword, string DomainName, string Path, string PrimaryDomainAdminUserName, string PrimaryDomainAdminPassword, string PrimaryDomainAdminFirstName, string PrimaryDomainAdminLastName, string IP) + { + object[] results = this.Invoke("AddDomainEx", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDomainEx(string AuthUserName, string AuthPassword, string DomainName, string Path, string PrimaryDomainAdminUserName, string PrimaryDomainAdminPassword, string PrimaryDomainAdminFirstName, string PrimaryDomainAdminLastName, string IP, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDomainEx", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP}, callback, asyncState); + } + + /// + public GenericResult EndAddDomainEx(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDomainExAsync(string AuthUserName, string AuthPassword, string DomainName, string Path, string PrimaryDomainAdminUserName, string PrimaryDomainAdminPassword, string PrimaryDomainAdminFirstName, string PrimaryDomainAdminLastName, string IP) + { + this.AddDomainExAsync(AuthUserName, AuthPassword, DomainName, Path, PrimaryDomainAdminUserName, PrimaryDomainAdminPassword, PrimaryDomainAdminFirstName, PrimaryDomainAdminLastName, IP, null); + } + + /// + public void AddDomainExAsync(string AuthUserName, string AuthPassword, string DomainName, string Path, string PrimaryDomainAdminUserName, string PrimaryDomainAdminPassword, string PrimaryDomainAdminFirstName, string PrimaryDomainAdminLastName, string IP, object userState) + { + if ((this.AddDomainExOperationCompleted == null)) + { + this.AddDomainExOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDomainExOperationCompleted); + } + this.InvokeAsync("AddDomainEx", new object[] { + AuthUserName, + AuthPassword, + DomainName, + Path, + PrimaryDomainAdminUserName, + PrimaryDomainAdminPassword, + PrimaryDomainAdminFirstName, + PrimaryDomainAdminLastName, + IP}, this.AddDomainExOperationCompleted, userState); + } + + private void OnAddDomainExOperationCompleted(object arg) + { + if ((this.AddDomainExCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDomainExCompleted(this, new AddDomainExCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateDomainNameAndPath", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateDomainNameAndPath(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, string NewDomainPath) + { + object[] results = this.Invoke("UpdateDomainNameAndPath", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName, + NewDomainPath}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateDomainNameAndPath(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, string NewDomainPath, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateDomainNameAndPath", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName, + NewDomainPath}, callback, asyncState); + } + + /// + public GenericResult EndUpdateDomainNameAndPath(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateDomainNameAndPathAsync(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, string NewDomainPath) + { + this.UpdateDomainNameAndPathAsync(AuthUserName, AuthPassword, OldDomainName, NewDomainName, NewDomainPath, null); + } + + /// + public void UpdateDomainNameAndPathAsync(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, string NewDomainPath, object userState) + { + if ((this.UpdateDomainNameAndPathOperationCompleted == null)) + { + this.UpdateDomainNameAndPathOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateDomainNameAndPathOperationCompleted); + } + this.InvokeAsync("UpdateDomainNameAndPath", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName, + NewDomainPath}, this.UpdateDomainNameAndPathOperationCompleted, userState); + } + + private void OnUpdateDomainNameAndPathOperationCompleted(object arg) + { + if ((this.UpdateDomainNameAndPathCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateDomainNameAndPathCompleted(this, new UpdateDomainNameAndPathCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GenerateDomainKeysCert", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainKeyResult GenerateDomainKeysCert(string AuthUserName, string AuthPassword, string DomainName, int KeySize, string selector) + { + object[] results = this.Invoke("GenerateDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName, + KeySize, + selector}); + return ((DomainKeyResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGenerateDomainKeysCert(string AuthUserName, string AuthPassword, string DomainName, int KeySize, string selector, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GenerateDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName, + KeySize, + selector}, callback, asyncState); + } + + /// + public DomainKeyResult EndGenerateDomainKeysCert(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainKeyResult)(results[0])); + } + + /// + public void GenerateDomainKeysCertAsync(string AuthUserName, string AuthPassword, string DomainName, int KeySize, string selector) + { + this.GenerateDomainKeysCertAsync(AuthUserName, AuthPassword, DomainName, KeySize, selector, null); + } + + /// + public void GenerateDomainKeysCertAsync(string AuthUserName, string AuthPassword, string DomainName, int KeySize, string selector, object userState) + { + if ((this.GenerateDomainKeysCertOperationCompleted == null)) + { + this.GenerateDomainKeysCertOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGenerateDomainKeysCertOperationCompleted); + } + this.InvokeAsync("GenerateDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName, + KeySize, + selector}, this.GenerateDomainKeysCertOperationCompleted, userState); + } + + private void OnGenerateDomainKeysCertOperationCompleted(object arg) + { + if ((this.GenerateDomainKeysCertCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GenerateDomainKeysCertCompleted(this, new GenerateDomainKeysCertCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainKeysCert", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainKeyResult GetDomainKeysCert(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((DomainKeyResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainKeysCert(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public DomainKeyResult EndGetDomainKeysCert(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainKeyResult)(results[0])); + } + + /// + public void GetDomainKeysCertAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetDomainKeysCertAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetDomainKeysCertAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetDomainKeysCertOperationCompleted == null)) + { + this.GetDomainKeysCertOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainKeysCertOperationCompleted); + } + this.InvokeAsync("GetDomainKeysCert", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetDomainKeysCertOperationCompleted, userState); + } + + private void OnGetDomainKeysCertOperationCompleted(object arg) + { + if ((this.GetDomainKeysCertCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainKeysCertCompleted(this, new GetDomainKeysCertCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RenameDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RenameDomain(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName) + { + object[] results = this.Invoke("RenameDomain", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRenameDomain(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RenameDomain", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName}, callback, asyncState); + } + + /// + public GenericResult EndRenameDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RenameDomainAsync(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName) + { + this.RenameDomainAsync(AuthUserName, AuthPassword, OldDomainName, NewDomainName, null); + } + + /// + public void RenameDomainAsync(string AuthUserName, string AuthPassword, string OldDomainName, string NewDomainName, object userState) + { + if ((this.RenameDomainOperationCompleted == null)) + { + this.RenameDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRenameDomainOperationCompleted); + } + this.InvokeAsync("RenameDomain", new object[] { + AuthUserName, + AuthPassword, + OldDomainName, + NewDomainName}, this.RenameDomainOperationCompleted, userState); + } + + private void OnRenameDomainOperationCompleted(object arg) + { + if ((this.RenameDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RenameDomainCompleted(this, new RenameDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ReloadDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult ReloadDomain(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("ReloadDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginReloadDomain(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ReloadDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public GenericResult EndReloadDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void ReloadDomainAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.ReloadDomainAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void ReloadDomainAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.ReloadDomainOperationCompleted == null)) + { + this.ReloadDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnReloadDomainOperationCompleted); + } + this.InvokeAsync("ReloadDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.ReloadDomainOperationCompleted, userState); + } + + private void OnReloadDomainOperationCompleted(object arg) + { + if ((this.ReloadDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ReloadDomainCompleted(this, new ReloadDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateDomain( + string AuthUserName, + string AuthPassword, + string DomainName, + string ServerIP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress) + { + object[] results = this.Invoke("UpdateDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ServerIP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateDomain( + string AuthUserName, + string AuthPassword, + string DomainName, + string ServerIP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress, + System.AsyncCallback callback, + object asyncState) + { + return this.BeginInvoke("UpdateDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ServerIP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}, callback, asyncState); + } + + /// + public GenericResult EndUpdateDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateDomainAsync( + string AuthUserName, + string AuthPassword, + string DomainName, + string ServerIP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress) + { + this.UpdateDomainAsync(AuthUserName, AuthPassword, DomainName, ServerIP, ImapPort, PopPort, SmtpPort, MaxAliases, MaxDomainSizeInMB, MaxDomainUsers, MaxMailboxSizeInMB, MaxMessageSize, MaxRecipients, MaxDomainAliases, MaxLists, ShowDomainAliasMenu, ShowContentFilteringMenu, ShowSpamMenu, ShowStatsMenu, RequireSmtpAuthentication, ShowListMenu, ListCommandAddress, null); + } + + /// + public void UpdateDomainAsync( + string AuthUserName, + string AuthPassword, + string DomainName, + string ServerIP, + int ImapPort, + int PopPort, + int SmtpPort, + int MaxAliases, + int MaxDomainSizeInMB, + int MaxDomainUsers, + int MaxMailboxSizeInMB, + int MaxMessageSize, + int MaxRecipients, + int MaxDomainAliases, + int MaxLists, + bool ShowDomainAliasMenu, + bool ShowContentFilteringMenu, + bool ShowSpamMenu, + bool ShowStatsMenu, + bool RequireSmtpAuthentication, + bool ShowListMenu, + string ListCommandAddress, + object userState) + { + if ((this.UpdateDomainOperationCompleted == null)) + { + this.UpdateDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateDomainOperationCompleted); + } + this.InvokeAsync("UpdateDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ServerIP, + ImapPort, + PopPort, + SmtpPort, + MaxAliases, + MaxDomainSizeInMB, + MaxDomainUsers, + MaxMailboxSizeInMB, + MaxMessageSize, + MaxRecipients, + MaxDomainAliases, + MaxLists, + ShowDomainAliasMenu, + ShowContentFilteringMenu, + ShowSpamMenu, + ShowStatsMenu, + RequireSmtpAuthentication, + ShowListMenu, + ListCommandAddress}, this.UpdateDomainOperationCompleted, userState); + } + + private void OnUpdateDomainOperationCompleted(object arg) + { + if ((this.UpdateDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateDomainCompleted(this, new UpdateDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetRequestedDomainDefaults", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SettingsRequestResult GetRequestedDomainDefaults(string AuthUserName, string AuthPassword, string[] requestedSettings) + { + object[] results = this.Invoke("GetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + requestedSettings}); + return ((SettingsRequestResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetRequestedDomainDefaults(string AuthUserName, string AuthPassword, string[] requestedSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + requestedSettings}, callback, asyncState); + } + + /// + public SettingsRequestResult EndGetRequestedDomainDefaults(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SettingsRequestResult)(results[0])); + } + + /// + public void GetRequestedDomainDefaultsAsync(string AuthUserName, string AuthPassword, string[] requestedSettings) + { + this.GetRequestedDomainDefaultsAsync(AuthUserName, AuthPassword, requestedSettings, null); + } + + /// + public void GetRequestedDomainDefaultsAsync(string AuthUserName, string AuthPassword, string[] requestedSettings, object userState) + { + if ((this.GetRequestedDomainDefaultsOperationCompleted == null)) + { + this.GetRequestedDomainDefaultsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRequestedDomainDefaultsOperationCompleted); + } + this.InvokeAsync("GetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + requestedSettings}, this.GetRequestedDomainDefaultsOperationCompleted, userState); + } + + private void OnGetRequestedDomainDefaultsOperationCompleted(object arg) + { + if ((this.GetRequestedDomainDefaultsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetRequestedDomainDefaultsCompleted(this, new GetRequestedDomainDefaultsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetRequestedDomainSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SettingsRequestResult GetRequestedDomainSettings(string AuthUserName, string AuthPassword, string DomainName, string[] requestedSettings) + { + object[] results = this.Invoke("GetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + requestedSettings}); + return ((SettingsRequestResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetRequestedDomainSettings(string AuthUserName, string AuthPassword, string DomainName, string[] requestedSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + requestedSettings}, callback, asyncState); + } + + /// + public SettingsRequestResult EndGetRequestedDomainSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SettingsRequestResult)(results[0])); + } + + /// + public void GetRequestedDomainSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string[] requestedSettings) + { + this.GetRequestedDomainSettingsAsync(AuthUserName, AuthPassword, DomainName, requestedSettings, null); + } + + /// + public void GetRequestedDomainSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string[] requestedSettings, object userState) + { + if ((this.GetRequestedDomainSettingsOperationCompleted == null)) + { + this.GetRequestedDomainSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRequestedDomainSettingsOperationCompleted); + } + this.InvokeAsync("GetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + requestedSettings}, this.GetRequestedDomainSettingsOperationCompleted, userState); + } + + private void OnGetRequestedDomainSettingsOperationCompleted(object arg) + { + if ((this.GetRequestedDomainSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetRequestedDomainSettingsCompleted(this, new GetRequestedDomainSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetRequestedDomainDefaults", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetRequestedDomainDefaults(string AuthUserName, string AuthPassword, string[] newSettings) + { + object[] results = this.Invoke("SetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + newSettings}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetRequestedDomainDefaults(string AuthUserName, string AuthPassword, string[] newSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + newSettings}, callback, asyncState); + } + + /// + public GenericResult EndSetRequestedDomainDefaults(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetRequestedDomainDefaultsAsync(string AuthUserName, string AuthPassword, string[] newSettings) + { + this.SetRequestedDomainDefaultsAsync(AuthUserName, AuthPassword, newSettings, null); + } + + /// + public void SetRequestedDomainDefaultsAsync(string AuthUserName, string AuthPassword, string[] newSettings, object userState) + { + if ((this.SetRequestedDomainDefaultsOperationCompleted == null)) + { + this.SetRequestedDomainDefaultsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRequestedDomainDefaultsOperationCompleted); + } + this.InvokeAsync("SetRequestedDomainDefaults", new object[] { + AuthUserName, + AuthPassword, + newSettings}, this.SetRequestedDomainDefaultsOperationCompleted, userState); + } + + private void OnSetRequestedDomainDefaultsOperationCompleted(object arg) + { + if ((this.SetRequestedDomainDefaultsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetRequestedDomainDefaultsCompleted(this, new SetRequestedDomainDefaultsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetRequestedDomainSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetRequestedDomainSettings(string AuthUserName, string AuthPassword, string DomainName, string[] newSettings) + { + object[] results = this.Invoke("SetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + newSettings}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetRequestedDomainSettings(string AuthUserName, string AuthPassword, string DomainName, string[] newSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + newSettings}, callback, asyncState); + } + + /// + public GenericResult EndSetRequestedDomainSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetRequestedDomainSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string[] newSettings) + { + this.SetRequestedDomainSettingsAsync(AuthUserName, AuthPassword, DomainName, newSettings, null); + } + + /// + public void SetRequestedDomainSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string[] newSettings, object userState) + { + if ((this.SetRequestedDomainSettingsOperationCompleted == null)) + { + this.SetRequestedDomainSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRequestedDomainSettingsOperationCompleted); + } + this.InvokeAsync("SetRequestedDomainSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + newSettings}, this.SetRequestedDomainSettingsOperationCompleted, userState); + } + + private void OnSetRequestedDomainSettingsOperationCompleted(object arg) + { + if ((this.SetRequestedDomainSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetRequestedDomainSettingsCompleted(this, new SetRequestedDomainSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteDomain(string AuthUserName, string AuthPassword, string DomainName, bool DeleteFiles) + { + object[] results = this.Invoke("DeleteDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DeleteFiles}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteDomain(string AuthUserName, string AuthPassword, string DomainName, bool DeleteFiles, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DeleteFiles}, callback, asyncState); + } + + /// + public GenericResult EndDeleteDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteDomainAsync(string AuthUserName, string AuthPassword, string DomainName, bool DeleteFiles) + { + this.DeleteDomainAsync(AuthUserName, AuthPassword, DomainName, DeleteFiles, null); + } + + /// + public void DeleteDomainAsync(string AuthUserName, string AuthPassword, string DomainName, bool DeleteFiles, object userState) + { + if ((this.DeleteDomainOperationCompleted == null)) + { + this.DeleteDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteDomainOperationCompleted); + } + this.InvokeAsync("DeleteDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DeleteFiles}, this.DeleteDomainOperationCompleted, userState); + } + + private void OnDeleteDomainOperationCompleted(object arg) + { + if ((this.DeleteDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteDomainCompleted(this, new DeleteDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAllDomains", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainListResult GetAllDomains(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetAllDomains", new object[] { + AuthUserName, + AuthPassword}); + return ((DomainListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAllDomains(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAllDomains", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public DomainListResult EndGetAllDomains(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainListResult)(results[0])); + } + + /// + public void GetAllDomainsAsync(string AuthUserName, string AuthPassword) + { + this.GetAllDomainsAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetAllDomainsAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetAllDomainsOperationCompleted == null)) + { + this.GetAllDomainsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAllDomainsOperationCompleted); + } + this.InvokeAsync("GetAllDomains", new object[] { + AuthUserName, + AuthPassword}, this.GetAllDomainsOperationCompleted, userState); + } + + private void OnGetAllDomainsOperationCompleted(object arg) + { + if ((this.GetAllDomainsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAllDomainsCompleted(this, new GetAllDomainsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainCounts", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainCountInfoResult GetDomainCounts(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetDomainCounts", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((DomainCountInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainCounts(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainCounts", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public DomainCountInfoResult EndGetDomainCounts(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainCountInfoResult)(results[0])); + } + + /// + public void GetDomainCountsAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetDomainCountsAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetDomainCountsAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetDomainCountsOperationCompleted == null)) + { + this.GetDomainCountsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainCountsOperationCompleted); + } + this.InvokeAsync("GetDomainCounts", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetDomainCountsOperationCompleted, userState); + } + + private void OnGetDomainCountsOperationCompleted(object arg) + { + if ((this.GetDomainCountsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainCountsCompleted(this, new GetDomainCountsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAllDomainAliases", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainAliasInfoResult GetAllDomainAliases(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetAllDomainAliases", new object[] { + AuthUserName, + AuthPassword}); + return ((DomainAliasInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAllDomainAliases(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAllDomainAliases", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public DomainAliasInfoResult EndGetAllDomainAliases(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainAliasInfoResult)(results[0])); + } + + /// + public void GetAllDomainAliasesAsync(string AuthUserName, string AuthPassword) + { + this.GetAllDomainAliasesAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetAllDomainAliasesAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetAllDomainAliasesOperationCompleted == null)) + { + this.GetAllDomainAliasesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAllDomainAliasesOperationCompleted); + } + this.InvokeAsync("GetAllDomainAliases", new object[] { + AuthUserName, + AuthPassword}, this.GetAllDomainAliasesOperationCompleted, userState); + } + + private void OnGetAllDomainAliasesOperationCompleted(object arg) + { + if ((this.GetAllDomainAliasesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAllDomainAliasesCompleted(this, new GetAllDomainAliasesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainUsers", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainUserInfoResult GetDomainUsers(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetDomainUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((DomainUserInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainUsers(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public DomainUserInfoResult EndGetDomainUsers(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainUserInfoResult)(results[0])); + } + + /// + public void GetDomainUsersAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetDomainUsersAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetDomainUsersAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetDomainUsersOperationCompleted == null)) + { + this.GetDomainUsersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainUsersOperationCompleted); + } + this.InvokeAsync("GetDomainUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetDomainUsersOperationCompleted, userState); + } + + private void OnGetDomainUsersOperationCompleted(object arg) + { + if ((this.GetDomainUsersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainUsersCompleted(this, new GetDomainUsersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainStatistics", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public StatInfoResult GetDomainStatistics(string AuthUserName, string AuthPassword, string DomainName, System.DateTime StartDate, System.DateTime EndDate) + { + object[] results = this.Invoke("GetDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + DomainName, + StartDate, + EndDate}); + return ((StatInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainStatistics(string AuthUserName, string AuthPassword, string DomainName, System.DateTime StartDate, System.DateTime EndDate, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + DomainName, + StartDate, + EndDate}, callback, asyncState); + } + + /// + public StatInfoResult EndGetDomainStatistics(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((StatInfoResult)(results[0])); + } + + /// + public void GetDomainStatisticsAsync(string AuthUserName, string AuthPassword, string DomainName, System.DateTime StartDate, System.DateTime EndDate) + { + this.GetDomainStatisticsAsync(AuthUserName, AuthPassword, DomainName, StartDate, EndDate, null); + } + + /// + public void GetDomainStatisticsAsync(string AuthUserName, string AuthPassword, string DomainName, System.DateTime StartDate, System.DateTime EndDate, object userState) + { + if ((this.GetDomainStatisticsOperationCompleted == null)) + { + this.GetDomainStatisticsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainStatisticsOperationCompleted); + } + this.InvokeAsync("GetDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + DomainName, + StartDate, + EndDate}, this.GetDomainStatisticsOperationCompleted, userState); + } + + private void OnGetDomainStatisticsOperationCompleted(object arg) + { + if ((this.GetDomainStatisticsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainStatisticsCompleted(this, new GetDomainStatisticsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAllDomainStatistics", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public AllDomainStatResult GetAllDomainStatistics(string AuthUserName, string AuthPassword, System.DateTime StartDate, System.DateTime EndDate) + { + object[] results = this.Invoke("GetAllDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + StartDate, + EndDate}); + return ((AllDomainStatResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAllDomainStatistics(string AuthUserName, string AuthPassword, System.DateTime StartDate, System.DateTime EndDate, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAllDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + StartDate, + EndDate}, callback, asyncState); + } + + /// + public AllDomainStatResult EndGetAllDomainStatistics(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((AllDomainStatResult)(results[0])); + } + + /// + public void GetAllDomainStatisticsAsync(string AuthUserName, string AuthPassword, System.DateTime StartDate, System.DateTime EndDate) + { + this.GetAllDomainStatisticsAsync(AuthUserName, AuthPassword, StartDate, EndDate, null); + } + + /// + public void GetAllDomainStatisticsAsync(string AuthUserName, string AuthPassword, System.DateTime StartDate, System.DateTime EndDate, object userState) + { + if ((this.GetAllDomainStatisticsOperationCompleted == null)) + { + this.GetAllDomainStatisticsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAllDomainStatisticsOperationCompleted); + } + this.InvokeAsync("GetAllDomainStatistics", new object[] { + AuthUserName, + AuthPassword, + StartDate, + EndDate}, this.GetAllDomainStatisticsOperationCompleted, userState); + } + + private void OnGetAllDomainStatisticsOperationCompleted(object arg) + { + if ((this.GetAllDomainStatisticsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAllDomainStatisticsCompleted(this, new GetAllDomainStatisticsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetPrimaryDomainAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public PrimaryDomainAdminResult GetPrimaryDomainAdmin(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((PrimaryDomainAdminResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetPrimaryDomainAdmin(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public PrimaryDomainAdminResult EndGetPrimaryDomainAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((PrimaryDomainAdminResult)(results[0])); + } + + /// + public void GetPrimaryDomainAdminAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetPrimaryDomainAdminAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetPrimaryDomainAdminAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetPrimaryDomainAdminOperationCompleted == null)) + { + this.GetPrimaryDomainAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetPrimaryDomainAdminOperationCompleted); + } + this.InvokeAsync("GetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetPrimaryDomainAdminOperationCompleted, userState); + } + + private void OnGetPrimaryDomainAdminOperationCompleted(object arg) + { + if ((this.GetPrimaryDomainAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetPrimaryDomainAdminCompleted(this, new GetPrimaryDomainAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetPrimaryDomainAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetPrimaryDomainAdmin(string AuthUserName, string AuthPassword, string DomainName, string AdminUserName) + { + object[] results = this.Invoke("SetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AdminUserName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetPrimaryDomainAdmin(string AuthUserName, string AuthPassword, string DomainName, string AdminUserName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AdminUserName}, callback, asyncState); + } + + /// + public GenericResult EndSetPrimaryDomainAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetPrimaryDomainAdminAsync(string AuthUserName, string AuthPassword, string DomainName, string AdminUserName) + { + this.SetPrimaryDomainAdminAsync(AuthUserName, AuthPassword, DomainName, AdminUserName, null); + } + + /// + public void SetPrimaryDomainAdminAsync(string AuthUserName, string AuthPassword, string DomainName, string AdminUserName, object userState) + { + if ((this.SetPrimaryDomainAdminOperationCompleted == null)) + { + this.SetPrimaryDomainAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetPrimaryDomainAdminOperationCompleted); + } + this.InvokeAsync("SetPrimaryDomainAdmin", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AdminUserName}, this.SetPrimaryDomainAdminOperationCompleted, userState); + } + + private void OnSetPrimaryDomainAdminOperationCompleted(object arg) + { + if ((this.SetPrimaryDomainAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetPrimaryDomainAdminCompleted(this, new SetPrimaryDomainAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainDefaults", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainSettingsResult GetDomainDefaults(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetDomainDefaults", new object[] { + AuthUserName, + AuthPassword}); + return ((DomainSettingsResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainDefaults(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainDefaults", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public DomainSettingsResult EndGetDomainDefaults(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainSettingsResult)(results[0])); + } + + /// + public void GetDomainDefaultsAsync(string AuthUserName, string AuthPassword) + { + this.GetDomainDefaultsAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetDomainDefaultsAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetDomainDefaultsOperationCompleted == null)) + { + this.GetDomainDefaultsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainDefaultsOperationCompleted); + } + this.InvokeAsync("GetDomainDefaults", new object[] { + AuthUserName, + AuthPassword}, this.GetDomainDefaultsOperationCompleted, userState); + } + + private void OnGetDomainDefaultsOperationCompleted(object arg) + { + if ((this.GetDomainDefaultsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainDefaultsCompleted(this, new GetDomainDefaultsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DisableDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DisableDomain(string AuthUserName, string AuthPassword, string domainName) + { + object[] results = this.Invoke("DisableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDisableDomain(string AuthUserName, string AuthPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DisableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}, callback, asyncState); + } + + /// + public GenericResult EndDisableDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DisableDomainAsync(string AuthUserName, string AuthPassword, string domainName) + { + this.DisableDomainAsync(AuthUserName, AuthPassword, domainName, null); + } + + /// + public void DisableDomainAsync(string AuthUserName, string AuthPassword, string domainName, object userState) + { + if ((this.DisableDomainOperationCompleted == null)) + { + this.DisableDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDisableDomainOperationCompleted); + } + this.InvokeAsync("DisableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}, this.DisableDomainOperationCompleted, userState); + } + + private void OnDisableDomainOperationCompleted(object arg) + { + if ((this.DisableDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DisableDomainCompleted(this, new DisableDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/EnableDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult EnableDomain(string AuthUserName, string AuthPassword, string domainName) + { + object[] results = this.Invoke("EnableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginEnableDomain(string AuthUserName, string AuthPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("EnableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}, callback, asyncState); + } + + /// + public GenericResult EndEnableDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void EnableDomainAsync(string AuthUserName, string AuthPassword, string domainName) + { + this.EnableDomainAsync(AuthUserName, AuthPassword, domainName, null); + } + + /// + public void EnableDomainAsync(string AuthUserName, string AuthPassword, string domainName, object userState) + { + if ((this.EnableDomainOperationCompleted == null)) + { + this.EnableDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnEnableDomainOperationCompleted); + } + this.InvokeAsync("EnableDomain", new object[] { + AuthUserName, + AuthPassword, + domainName}, this.EnableDomainOperationCompleted, userState); + } + + private void OnEnableDomainOperationCompleted(object arg) + { + if ((this.EnableDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.EnableDomainCompleted(this, new EnableDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainInfo", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainInfoResult GetDomainInfo(string AuthUserName, string AuthPassword, string domainName) + { + object[] results = this.Invoke("GetDomainInfo", new object[] { + AuthUserName, + AuthPassword, + domainName}); + return ((DomainInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainInfo(string AuthUserName, string AuthPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainInfo", new object[] { + AuthUserName, + AuthPassword, + domainName}, callback, asyncState); + } + + /// + public DomainInfoResult EndGetDomainInfo(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainInfoResult)(results[0])); + } + + /// + public void GetDomainInfoAsync(string AuthUserName, string AuthPassword, string domainName) + { + this.GetDomainInfoAsync(AuthUserName, AuthPassword, domainName, null); + } + + /// + public void GetDomainInfoAsync(string AuthUserName, string AuthPassword, string domainName, object userState) + { + if ((this.GetDomainInfoOperationCompleted == null)) + { + this.GetDomainInfoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainInfoOperationCompleted); + } + this.InvokeAsync("GetDomainInfo", new object[] { + AuthUserName, + AuthPassword, + domainName}, this.GetDomainInfoOperationCompleted, userState); + } + + private void OnGetDomainInfoOperationCompleted(object arg) + { + if ((this.GetDomainInfoCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainInfoCompleted(this, new GetDomainInfoCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainSettingsResult GetDomainSettings(string AuthUserName, string AuthPassword, string domainName) + { + object[] results = this.Invoke("GetDomainSettings", new object[] { + AuthUserName, + AuthPassword, + domainName}); + return ((DomainSettingsResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainSettings(string AuthUserName, string AuthPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainSettings", new object[] { + AuthUserName, + AuthPassword, + domainName}, callback, asyncState); + } + + /// + public DomainSettingsResult EndGetDomainSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainSettingsResult)(results[0])); + } + + /// + public void GetDomainSettingsAsync(string AuthUserName, string AuthPassword, string domainName) + { + this.GetDomainSettingsAsync(AuthUserName, AuthPassword, domainName, null); + } + + /// + public void GetDomainSettingsAsync(string AuthUserName, string AuthPassword, string domainName, object userState) + { + if ((this.GetDomainSettingsOperationCompleted == null)) + { + this.GetDomainSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainSettingsOperationCompleted); + } + this.InvokeAsync("GetDomainSettings", new object[] { + AuthUserName, + AuthPassword, + domainName}, this.GetDomainSettingsOperationCompleted, userState); + } + + private void OnGetDomainSettingsOperationCompleted(object arg) + { + if ((this.GetDomainSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainSettingsCompleted(this, new GetDomainSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainForwarding", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainForwardInfoResult GetDomainForwarding(string AuthUserName, string AuthPassword, bool includeDomains) + { + object[] results = this.Invoke("GetDomainForwarding", new object[] { + AuthUserName, + AuthPassword, + includeDomains}); + return ((DomainForwardInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainForwarding(string AuthUserName, string AuthPassword, bool includeDomains, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainForwarding", new object[] { + AuthUserName, + AuthPassword, + includeDomains}, callback, asyncState); + } + + /// + public DomainForwardInfoResult EndGetDomainForwarding(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainForwardInfoResult)(results[0])); + } + + /// + public void GetDomainForwardingAsync(string AuthUserName, string AuthPassword, bool includeDomains) + { + this.GetDomainForwardingAsync(AuthUserName, AuthPassword, includeDomains, null); + } + + /// + public void GetDomainForwardingAsync(string AuthUserName, string AuthPassword, bool includeDomains, object userState) + { + if ((this.GetDomainForwardingOperationCompleted == null)) + { + this.GetDomainForwardingOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainForwardingOperationCompleted); + } + this.InvokeAsync("GetDomainForwarding", new object[] { + AuthUserName, + AuthPassword, + includeDomains}, this.GetDomainForwardingOperationCompleted, userState); + } + + private void OnGetDomainForwardingOperationCompleted(object arg) + { + if ((this.GetDomainForwardingCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainForwardingCompleted(this, new GetDomainForwardingCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainForwardingBlock", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainForwardBlockInfoResult GetDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID) + { + object[] results = this.Invoke("GetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}); + return ((DomainForwardBlockInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}, callback, asyncState); + } + + /// + public DomainForwardBlockInfoResult EndGetDomainForwardingBlock(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainForwardBlockInfoResult)(results[0])); + } + + /// + public void GetDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID) + { + this.GetDomainForwardingBlockAsync(AuthUserName, AuthPassword, blockID, null); + } + + /// + public void GetDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID, object userState) + { + if ((this.GetDomainForwardingBlockOperationCompleted == null)) + { + this.GetDomainForwardingBlockOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainForwardingBlockOperationCompleted); + } + this.InvokeAsync("GetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}, this.GetDomainForwardingBlockOperationCompleted, userState); + } + + private void OnGetDomainForwardingBlockOperationCompleted(object arg) + { + if ((this.GetDomainForwardingBlockCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainForwardingBlockCompleted(this, new GetDomainForwardingBlockCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDomainForwardingBlockByTargetAddress", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainForwardBlockInfoResult GetDomainForwardingBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress) + { + object[] results = this.Invoke("GetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}); + return ((DomainForwardBlockInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDomainForwardingBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}, callback, asyncState); + } + + /// + public DomainForwardBlockInfoResult EndGetDomainForwardingBlockByTargetAddress(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainForwardBlockInfoResult)(results[0])); + } + + /// + public void GetDomainForwardingBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress) + { + this.GetDomainForwardingBlockByTargetAddressAsync(AuthUserName, AuthPassword, targetAddress, null); + } + + /// + public void GetDomainForwardingBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress, object userState) + { + if ((this.GetDomainForwardingBlockByTargetAddressOperationCompleted == null)) + { + this.GetDomainForwardingBlockByTargetAddressOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDomainForwardingBlockByTargetAddressOperationCompleted); + } + this.InvokeAsync("GetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}, this.GetDomainForwardingBlockByTargetAddressOperationCompleted, userState); + } + + private void OnGetDomainForwardingBlockByTargetAddressOperationCompleted(object arg) + { + if ((this.GetDomainForwardingBlockByTargetAddressCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDomainForwardingBlockByTargetAddressCompleted(this, new GetDomainForwardingBlockByTargetAddressCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetDomainForwardingBlock", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID, string targetAddress, string[] domains) + { + object[] results = this.Invoke("SetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID, + targetAddress, + domains}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID, string targetAddress, string[] domains, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID, + targetAddress, + domains}, callback, asyncState); + } + + /// + public GenericResult EndSetDomainForwardingBlock(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID, string targetAddress, string[] domains) + { + this.SetDomainForwardingBlockAsync(AuthUserName, AuthPassword, blockID, targetAddress, domains, null); + } + + /// + public void SetDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID, string targetAddress, string[] domains, object userState) + { + if ((this.SetDomainForwardingBlockOperationCompleted == null)) + { + this.SetDomainForwardingBlockOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDomainForwardingBlockOperationCompleted); + } + this.InvokeAsync("SetDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID, + targetAddress, + domains}, this.SetDomainForwardingBlockOperationCompleted, userState); + } + + private void OnSetDomainForwardingBlockOperationCompleted(object arg) + { + if ((this.SetDomainForwardingBlockCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetDomainForwardingBlockCompleted(this, new SetDomainForwardingBlockCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetDomainForwardingBlockByTargetAddress", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetDomainForwardingBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress, string[] domains) + { + object[] results = this.Invoke("SetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetDomainForwardingBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress, string[] domains, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}, callback, asyncState); + } + + /// + public GenericResult EndSetDomainForwardingBlockByTargetAddress(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetDomainForwardingBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress, string[] domains) + { + this.SetDomainForwardingBlockByTargetAddressAsync(AuthUserName, AuthPassword, targetAddress, domains, null); + } + + /// + public void SetDomainForwardingBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress, string[] domains, object userState) + { + if ((this.SetDomainForwardingBlockByTargetAddressOperationCompleted == null)) + { + this.SetDomainForwardingBlockByTargetAddressOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDomainForwardingBlockByTargetAddressOperationCompleted); + } + this.InvokeAsync("SetDomainForwardingBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}, this.SetDomainForwardingBlockByTargetAddressOperationCompleted, userState); + } + + private void OnSetDomainForwardingBlockByTargetAddressOperationCompleted(object arg) + { + if ((this.SetDomainForwardingBlockByTargetAddressCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetDomainForwardingBlockByTargetAddressCompleted(this, new SetDomainForwardingBlockByTargetAddressCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDomainForwardingBlock", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDomainForwardingBlock(string AuthUserName, string AuthPassword, string targetAddress, string[] domains) + { + object[] results = this.Invoke("AddDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDomainForwardingBlock(string AuthUserName, string AuthPassword, string targetAddress, string[] domains, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}, callback, asyncState); + } + + /// + public GenericResult EndAddDomainForwardingBlock(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, string targetAddress, string[] domains) + { + this.AddDomainForwardingBlockAsync(AuthUserName, AuthPassword, targetAddress, domains, null); + } + + /// + public void AddDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, string targetAddress, string[] domains, object userState) + { + if ((this.AddDomainForwardingBlockOperationCompleted == null)) + { + this.AddDomainForwardingBlockOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDomainForwardingBlockOperationCompleted); + } + this.InvokeAsync("AddDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + targetAddress, + domains}, this.AddDomainForwardingBlockOperationCompleted, userState); + } + + private void OnAddDomainForwardingBlockOperationCompleted(object arg) + { + if ((this.AddDomainForwardingBlockCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDomainForwardingBlockCompleted(this, new AddDomainForwardingBlockCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteDomainForwardingBlock", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID) + { + object[] results = this.Invoke("DeleteDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteDomainForwardingBlock(string AuthUserName, string AuthPassword, int blockID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}, callback, asyncState); + } + + /// + public GenericResult EndDeleteDomainForwardingBlock(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID) + { + this.DeleteDomainForwardingBlockAsync(AuthUserName, AuthPassword, blockID, null); + } + + /// + public void DeleteDomainForwardingBlockAsync(string AuthUserName, string AuthPassword, int blockID, object userState) + { + if ((this.DeleteDomainForwardingBlockOperationCompleted == null)) + { + this.DeleteDomainForwardingBlockOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteDomainForwardingBlockOperationCompleted); + } + this.InvokeAsync("DeleteDomainForwardingBlock", new object[] { + AuthUserName, + AuthPassword, + blockID}, this.DeleteDomainForwardingBlockOperationCompleted, userState); + } + + private void OnDeleteDomainForwardingBlockOperationCompleted(object arg) + { + if ((this.DeleteDomainForwardingBlockCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteDomainForwardingBlockCompleted(this, new DeleteDomainForwardingBlockCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteDomainForwardBlockByTargetAddress", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteDomainForwardBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress) + { + object[] results = this.Invoke("DeleteDomainForwardBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteDomainForwardBlockByTargetAddress(string AuthUserName, string AuthPassword, string targetAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteDomainForwardBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}, callback, asyncState); + } + + /// + public GenericResult EndDeleteDomainForwardBlockByTargetAddress(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteDomainForwardBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress) + { + this.DeleteDomainForwardBlockByTargetAddressAsync(AuthUserName, AuthPassword, targetAddress, null); + } + + /// + public void DeleteDomainForwardBlockByTargetAddressAsync(string AuthUserName, string AuthPassword, string targetAddress, object userState) + { + if ((this.DeleteDomainForwardBlockByTargetAddressOperationCompleted == null)) + { + this.DeleteDomainForwardBlockByTargetAddressOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteDomainForwardBlockByTargetAddressOperationCompleted); + } + this.InvokeAsync("DeleteDomainForwardBlockByTargetAddress", new object[] { + AuthUserName, + AuthPassword, + targetAddress}, this.DeleteDomainForwardBlockByTargetAddressOperationCompleted, userState); + } + + private void OnDeleteDomainForwardBlockByTargetAddressOperationCompleted(object arg) + { + if ((this.DeleteDomainForwardBlockByTargetAddressCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteDomainForwardBlockByTargetAddressCompleted(this, new DeleteDomainForwardBlockByTargetAddressCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetDomainArchiveRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SettingsRequestResult SetDomainArchiveRule(string AuthUserName, string AuthPassword, string[] parameters) + { + object[] results = this.Invoke("SetDomainArchiveRule", new object[] { + AuthUserName, + AuthPassword, + parameters}); + return ((SettingsRequestResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetDomainArchiveRule(string AuthUserName, string AuthPassword, string[] parameters, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetDomainArchiveRule", new object[] { + AuthUserName, + AuthPassword, + parameters}, callback, asyncState); + } + + /// + public SettingsRequestResult EndSetDomainArchiveRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SettingsRequestResult)(results[0])); + } + + /// + public void SetDomainArchiveRuleAsync(string AuthUserName, string AuthPassword, string[] parameters) + { + this.SetDomainArchiveRuleAsync(AuthUserName, AuthPassword, parameters, null); + } + + /// + public void SetDomainArchiveRuleAsync(string AuthUserName, string AuthPassword, string[] parameters, object userState) + { + if ((this.SetDomainArchiveRuleOperationCompleted == null)) + { + this.SetDomainArchiveRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDomainArchiveRuleOperationCompleted); + } + this.InvokeAsync("SetDomainArchiveRule", new object[] { + AuthUserName, + AuthPassword, + parameters}, this.SetDomainArchiveRuleOperationCompleted, userState); + } + + private void OnSetDomainArchiveRuleOperationCompleted(object arg) + { + if ((this.SetDomainArchiveRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetDomainArchiveRuleCompleted(this, new SetDomainArchiveRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class GenericResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainForwardBlockInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private DomainForwardBlockInfo domainForwardBlockField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public DomainForwardBlockInfo domainForwardBlock + { + get + { + return this.domainForwardBlockField; + } + set + { + this.domainForwardBlockField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainForwardBlockInfo + { + + private int blockIDField; + + private string targetAddressField; + + private string[] domainsField; + + /// + public int blockID + { + get + { + return this.blockIDField; + } + set + { + this.blockIDField = value; + } + } + + /// + public string targetAddress + { + get + { + return this.targetAddressField; + } + set + { + this.targetAddressField = value; + } + } + + /// + public string[] domains + { + get + { + return this.domainsField; + } + set + { + this.domainsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainForwardInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private DomainForwardBlockInfo[] blocksField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public DomainForwardBlockInfo[] blocks + { + get + { + return this.blocksField; + } + set + { + this.blocksField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string pathField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string Path + { + get + { + return this.pathField; + } + set + { + this.pathField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainSettingsResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string serverIPField; + + private string pathField; + + private int imapPortField; + + private int popPortField; + + private int smtpPortField; + + private int maxAliasesField; + + private int maxDomainAliasesField; + + private int maxListsField; + + private int maxDomainSizeInMBField; + + private int maxDomainUsersField; + + private int maxMailboxSizeInMBField; + + private int maxMessageSizeField; + + private int maxRecipientsField; + + private bool showDomainAliasMenuField; + + private bool showContentFilteringMenuField; + + private bool showSpamMenuField; + + private bool showStatsMenuField; + + private bool showListMenuField; + + private bool requireSmtpAuthenticationField; + + private string listCommandAddressField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string ServerIP + { + get + { + return this.serverIPField; + } + set + { + this.serverIPField = value; + } + } + + /// + public string Path + { + get + { + return this.pathField; + } + set + { + this.pathField = value; + } + } + + /// + public int ImapPort + { + get + { + return this.imapPortField; + } + set + { + this.imapPortField = value; + } + } + + /// + public int PopPort + { + get + { + return this.popPortField; + } + set + { + this.popPortField = value; + } + } + + /// + public int SmtpPort + { + get + { + return this.smtpPortField; + } + set + { + this.smtpPortField = value; + } + } + + /// + public int MaxAliases + { + get + { + return this.maxAliasesField; + } + set + { + this.maxAliasesField = value; + } + } + + /// + public int MaxDomainAliases + { + get + { + return this.maxDomainAliasesField; + } + set + { + this.maxDomainAliasesField = value; + } + } + + /// + public int MaxLists + { + get + { + return this.maxListsField; + } + set + { + this.maxListsField = value; + } + } + + /// + public int MaxDomainSizeInMB + { + get + { + return this.maxDomainSizeInMBField; + } + set + { + this.maxDomainSizeInMBField = value; + } + } + + /// + public int MaxDomainUsers + { + get + { + return this.maxDomainUsersField; + } + set + { + this.maxDomainUsersField = value; + } + } + + /// + public int MaxMailboxSizeInMB + { + get + { + return this.maxMailboxSizeInMBField; + } + set + { + this.maxMailboxSizeInMBField = value; + } + } + + /// + public int MaxMessageSize + { + get + { + return this.maxMessageSizeField; + } + set + { + this.maxMessageSizeField = value; + } + } + + /// + public int MaxRecipients + { + get + { + return this.maxRecipientsField; + } + set + { + this.maxRecipientsField = value; + } + } + + /// + public bool ShowDomainAliasMenu + { + get + { + return this.showDomainAliasMenuField; + } + set + { + this.showDomainAliasMenuField = value; + } + } + + /// + public bool ShowContentFilteringMenu + { + get + { + return this.showContentFilteringMenuField; + } + set + { + this.showContentFilteringMenuField = value; + } + } + + /// + public bool ShowSpamMenu + { + get + { + return this.showSpamMenuField; + } + set + { + this.showSpamMenuField = value; + } + } + + /// + public bool ShowStatsMenu + { + get + { + return this.showStatsMenuField; + } + set + { + this.showStatsMenuField = value; + } + } + + /// + public bool ShowListMenu + { + get + { + return this.showListMenuField; + } + set + { + this.showListMenuField = value; + } + } + + /// + public bool RequireSmtpAuthentication + { + get + { + return this.requireSmtpAuthenticationField; + } + set + { + this.requireSmtpAuthenticationField = value; + } + } + + /// + public string ListCommandAddress + { + get + { + return this.listCommandAddressField; + } + set + { + this.listCommandAddressField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class PrimaryDomainAdminResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string primaryAdminField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string PrimaryAdmin + { + get + { + return this.primaryAdminField; + } + set + { + this.primaryAdminField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainStatInfo + { + + private string domainNameField; + + private long messagesReceivedField; + + private long messagesSentField; + + private long bytesReceivedField; + + private long bytesSentField; + + private long bytesSizeField; + + /// + public string DomainName + { + get + { + return this.domainNameField; + } + set + { + this.domainNameField = value; + } + } + + /// + public long MessagesReceived + { + get + { + return this.messagesReceivedField; + } + set + { + this.messagesReceivedField = value; + } + } + + /// + public long MessagesSent + { + get + { + return this.messagesSentField; + } + set + { + this.messagesSentField = value; + } + } + + /// + public long BytesReceived + { + get + { + return this.bytesReceivedField; + } + set + { + this.bytesReceivedField = value; + } + } + + /// + public long BytesSent + { + get + { + return this.bytesSentField; + } + set + { + this.bytesSentField = value; + } + } + + /// + public long BytesSize + { + get + { + return this.bytesSizeField; + } + set + { + this.bytesSizeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class AllDomainStatResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private DomainStatInfo[] statsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public DomainStatInfo[] Stats + { + get + { + return this.statsField; + } + set + { + this.statsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class StatInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private long messagesReceivedField; + + private long messagesSentField; + + private long bytesReceivedField; + + private long bytesSentField; + + private long bytesSizeField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public long MessagesReceived + { + get + { + return this.messagesReceivedField; + } + set + { + this.messagesReceivedField = value; + } + } + + /// + public long MessagesSent + { + get + { + return this.messagesSentField; + } + set + { + this.messagesSentField = value; + } + } + + /// + public long BytesReceived + { + get + { + return this.bytesReceivedField; + } + set + { + this.bytesReceivedField = value; + } + } + + /// + public long BytesSent + { + get + { + return this.bytesSentField; + } + set + { + this.bytesSentField = value; + } + } + + /// + public long BytesSize + { + get + { + return this.bytesSizeField; + } + set + { + this.bytesSizeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainUserInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] usersField; + + private string[] domainAliasesField; + + private bool catchAllField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] Users + { + get + { + return this.usersField; + } + set + { + this.usersField = value; + } + } + + /// + public string[] DomainAliases + { + get + { + return this.domainAliasesField; + } + set + { + this.domainAliasesField = value; + } + } + + /// + public bool CatchAll + { + get + { + return this.catchAllField; + } + set + { + this.catchAllField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainAliasInfo + { + + private string nameField; + + private string domainNameField; + + /// + public string Name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public string DomainName + { + get + { + return this.domainNameField; + } + set + { + this.domainNameField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainAliasInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private DomainAliasInfo[] domainAliasesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public DomainAliasInfo[] DomainAliases + { + get + { + return this.domainAliasesField; + } + set + { + this.domainAliasesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainCountInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private int usersField; + + private int mailingListsField; + + private int aliasesField; + + private long sizeField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public int Users + { + get + { + return this.usersField; + } + set + { + this.usersField = value; + } + } + + /// + public int MailingLists + { + get + { + return this.mailingListsField; + } + set + { + this.mailingListsField = value; + } + } + + /// + public int Aliases + { + get + { + return this.aliasesField; + } + set + { + this.aliasesField = value; + } + } + + /// + public long Size + { + get + { + return this.sizeField; + } + set + { + this.sizeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] domainNamesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] DomainNames + { + get + { + return this.domainNamesField; + } + set + { + this.domainNamesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SettingsRequestResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] settingValuesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] settingValues + { + get + { + return this.settingValuesField; + } + set + { + this.settingValuesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainKeyResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string privateKeyField; + + private string publicKeyField; + + private string selectorField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string privateKey + { + get + { + return this.privateKeyField; + } + set + { + this.privateKeyField = value; + } + } + + /// + public string publicKey + { + get + { + return this.publicKeyField; + } + set + { + this.publicKeyField = value; + } + } + + /// + public string selector + { + get + { + return this.selectorField; + } + set + { + this.selectorField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDomainCompletedEventHandler(object sender, AddDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDomainExCompletedEventHandler(object sender, AddDomainExCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDomainExCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDomainExCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateDomainNameAndPathCompletedEventHandler(object sender, UpdateDomainNameAndPathCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateDomainNameAndPathCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateDomainNameAndPathCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GenerateDomainKeysCertCompletedEventHandler(object sender, GenerateDomainKeysCertCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GenerateDomainKeysCertCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GenerateDomainKeysCertCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainKeyResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainKeyResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainKeysCertCompletedEventHandler(object sender, GetDomainKeysCertCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainKeysCertCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainKeysCertCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainKeyResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainKeyResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RenameDomainCompletedEventHandler(object sender, RenameDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RenameDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RenameDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ReloadDomainCompletedEventHandler(object sender, ReloadDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ReloadDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ReloadDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateDomainCompletedEventHandler(object sender, UpdateDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetRequestedDomainDefaultsCompletedEventHandler(object sender, GetRequestedDomainDefaultsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetRequestedDomainDefaultsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetRequestedDomainDefaultsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SettingsRequestResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SettingsRequestResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetRequestedDomainSettingsCompletedEventHandler(object sender, GetRequestedDomainSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetRequestedDomainSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetRequestedDomainSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SettingsRequestResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SettingsRequestResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetRequestedDomainDefaultsCompletedEventHandler(object sender, SetRequestedDomainDefaultsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetRequestedDomainDefaultsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetRequestedDomainDefaultsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetRequestedDomainSettingsCompletedEventHandler(object sender, SetRequestedDomainSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetRequestedDomainSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetRequestedDomainSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteDomainCompletedEventHandler(object sender, DeleteDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetAllDomainsCompletedEventHandler(object sender, GetAllDomainsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetAllDomainsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetAllDomainsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainCountsCompletedEventHandler(object sender, GetDomainCountsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainCountsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainCountsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainCountInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainCountInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetAllDomainAliasesCompletedEventHandler(object sender, GetAllDomainAliasesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetAllDomainAliasesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetAllDomainAliasesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainAliasInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainAliasInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainUsersCompletedEventHandler(object sender, GetDomainUsersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainUsersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainUsersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainUserInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainUserInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainStatisticsCompletedEventHandler(object sender, GetDomainStatisticsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainStatisticsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainStatisticsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public StatInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((StatInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetAllDomainStatisticsCompletedEventHandler(object sender, GetAllDomainStatisticsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetAllDomainStatisticsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetAllDomainStatisticsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public AllDomainStatResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((AllDomainStatResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetPrimaryDomainAdminCompletedEventHandler(object sender, GetPrimaryDomainAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetPrimaryDomainAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetPrimaryDomainAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public PrimaryDomainAdminResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((PrimaryDomainAdminResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetPrimaryDomainAdminCompletedEventHandler(object sender, SetPrimaryDomainAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetPrimaryDomainAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetPrimaryDomainAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainDefaultsCompletedEventHandler(object sender, GetDomainDefaultsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainDefaultsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainDefaultsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainSettingsResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainSettingsResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DisableDomainCompletedEventHandler(object sender, DisableDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DisableDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DisableDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void EnableDomainCompletedEventHandler(object sender, EnableDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class EnableDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal EnableDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainInfoCompletedEventHandler(object sender, GetDomainInfoCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainInfoCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainInfoCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainSettingsCompletedEventHandler(object sender, GetDomainSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainSettingsResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainSettingsResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainForwardingCompletedEventHandler(object sender, GetDomainForwardingCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainForwardingCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainForwardingCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainForwardInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainForwardInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainForwardingBlockCompletedEventHandler(object sender, GetDomainForwardingBlockCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainForwardingBlockCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainForwardingBlockCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainForwardBlockInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainForwardBlockInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDomainForwardingBlockByTargetAddressCompletedEventHandler(object sender, GetDomainForwardingBlockByTargetAddressCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDomainForwardingBlockByTargetAddressCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDomainForwardingBlockByTargetAddressCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DomainForwardBlockInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DomainForwardBlockInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetDomainForwardingBlockCompletedEventHandler(object sender, SetDomainForwardingBlockCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetDomainForwardingBlockCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetDomainForwardingBlockCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetDomainForwardingBlockByTargetAddressCompletedEventHandler(object sender, SetDomainForwardingBlockByTargetAddressCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetDomainForwardingBlockByTargetAddressCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetDomainForwardingBlockByTargetAddressCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDomainForwardingBlockCompletedEventHandler(object sender, AddDomainForwardingBlockCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDomainForwardingBlockCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDomainForwardingBlockCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteDomainForwardingBlockCompletedEventHandler(object sender, DeleteDomainForwardingBlockCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteDomainForwardingBlockCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteDomainForwardingBlockCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteDomainForwardBlockByTargetAddressCompletedEventHandler(object sender, DeleteDomainForwardBlockByTargetAddressCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteDomainForwardBlockByTargetAddressCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteDomainForwardBlockByTargetAddressCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetDomainArchiveRuleCompletedEventHandler(object sender, SetDomainArchiveRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetDomainArchiveRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetDomainArchiveRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SettingsRequestResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SettingsRequestResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcUserAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcUserAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback QueueMailBoxMigrationOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveFromMigrationQueueOperationCompleted; + + private System.Threading.SendOrPostCallback GetMigrationStatusOperationCompleted; + + private System.Threading.SendOrPostCallback AddUserOperationCompleted; + + private System.Threading.SendOrPostCallback AddUser2OperationCompleted; + + private System.Threading.SendOrPostCallback AuthenticateUserOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUserOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUser2OperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUserForwardingInfoOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUserForwardingInfo2OperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUserAutoResponseInfoOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteUserOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserOperationCompleted; + + private System.Threading.SendOrPostCallback GetLastLoginTimesOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedUserSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback SetRequestedUserSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetInactiveUsersOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserForwardingInfo2OperationCompleted; + + private System.Threading.SendOrPostCallback GetUserForwardingInfoOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserAutoResponseInfoOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserQuotasOperationCompleted; + + private System.Threading.SendOrPostCallback GetUsersOperationCompleted; + + private System.Threading.SendOrPostCallback LoginValidatedOperationCompleted; + + private System.Threading.SendOrPostCallback AddRSSFeedOperationCompleted; + + private System.Threading.SendOrPostCallback ToggleActiveSyncOperationCompleted; + + private System.Threading.SendOrPostCallback IsUserEnabledForActiveSyncOperationCompleted; + + private System.Threading.SendOrPostCallback ListRSSFeedsOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteRSSFeedOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserStatsOperationCompleted; + + private System.Threading.SendOrPostCallback AddUserGroupOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveUserGroupOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateUserGroupOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserGroupOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserGroupsByUserOperationCompleted; + + private System.Threading.SendOrPostCallback GetUserGroupsByDomainOperationCompleted; + + /// + public svcUserAdmin() + { + this.Url = "http://127.0.0.1:9998/Services/svcUserAdmin.asmx"; + } + + /// + public event QueueMailBoxMigrationCompletedEventHandler QueueMailBoxMigrationCompleted; + + /// + public event RemoveFromMigrationQueueCompletedEventHandler RemoveFromMigrationQueueCompleted; + + /// + public event GetMigrationStatusCompletedEventHandler GetMigrationStatusCompleted; + + /// + public event AddUserCompletedEventHandler AddUserCompleted; + + /// + public event AddUser2CompletedEventHandler AddUser2Completed; + + /// + public event AuthenticateUserCompletedEventHandler AuthenticateUserCompleted; + + /// + public event UpdateUserCompletedEventHandler UpdateUserCompleted; + + /// + public event UpdateUser2CompletedEventHandler UpdateUser2Completed; + + /// + public event UpdateUserForwardingInfoCompletedEventHandler UpdateUserForwardingInfoCompleted; + + /// + public event UpdateUserForwardingInfo2CompletedEventHandler UpdateUserForwardingInfo2Completed; + + /// + public event UpdateUserAutoResponseInfoCompletedEventHandler UpdateUserAutoResponseInfoCompleted; + + /// + public event DeleteUserCompletedEventHandler DeleteUserCompleted; + + /// + public event GetUserCompletedEventHandler GetUserCompleted; + + /// + public event GetLastLoginTimesCompletedEventHandler GetLastLoginTimesCompleted; + + /// + public event GetRequestedUserSettingsCompletedEventHandler GetRequestedUserSettingsCompleted; + + /// + public event SetRequestedUserSettingsCompletedEventHandler SetRequestedUserSettingsCompleted; + + /// + public event GetInactiveUsersCompletedEventHandler GetInactiveUsersCompleted; + + /// + public event GetUserForwardingInfo2CompletedEventHandler GetUserForwardingInfo2Completed; + + /// + public event GetUserForwardingInfoCompletedEventHandler GetUserForwardingInfoCompleted; + + /// + public event GetUserAutoResponseInfoCompletedEventHandler GetUserAutoResponseInfoCompleted; + + /// + public event GetUserQuotasCompletedEventHandler GetUserQuotasCompleted; + + /// + public event GetUsersCompletedEventHandler GetUsersCompleted; + + /// + public event LoginValidatedCompletedEventHandler LoginValidatedCompleted; + + /// + public event AddRSSFeedCompletedEventHandler AddRSSFeedCompleted; + + /// + public event ToggleActiveSyncCompletedEventHandler ToggleActiveSyncCompleted; + + /// + public event IsUserEnabledForActiveSyncCompletedEventHandler IsUserEnabledForActiveSyncCompleted; + + /// + public event ListRSSFeedsCompletedEventHandler ListRSSFeedsCompleted; + + /// + public event DeleteRSSFeedCompletedEventHandler DeleteRSSFeedCompleted; + + /// + public event GetUserStatsCompletedEventHandler GetUserStatsCompleted; + + /// + public event AddUserGroupCompletedEventHandler AddUserGroupCompleted; + + /// + public event RemoveUserGroupCompletedEventHandler RemoveUserGroupCompleted; + + /// + public event UpdateUserGroupCompletedEventHandler UpdateUserGroupCompleted; + + /// + public event GetUserGroupCompletedEventHandler GetUserGroupCompleted; + + /// + public event GetUserGroupsByUserCompletedEventHandler GetUserGroupsByUserCompleted; + + /// + public event GetUserGroupsByDomainCompletedEventHandler GetUserGroupsByDomainCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/QueueMailBoxMigration", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public RequestStatusResult QueueMailBoxMigration(string AuthUserName, string AuthPassword, string[] parameters) + { + object[] results = this.Invoke("QueueMailBoxMigration", new object[] { + AuthUserName, + AuthPassword, + parameters}); + return ((RequestStatusResult)(results[0])); + } + + /// + public System.IAsyncResult BeginQueueMailBoxMigration(string AuthUserName, string AuthPassword, string[] parameters, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("QueueMailBoxMigration", new object[] { + AuthUserName, + AuthPassword, + parameters}, callback, asyncState); + } + + /// + public RequestStatusResult EndQueueMailBoxMigration(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((RequestStatusResult)(results[0])); + } + + /// + public void QueueMailBoxMigrationAsync(string AuthUserName, string AuthPassword, string[] parameters) + { + this.QueueMailBoxMigrationAsync(AuthUserName, AuthPassword, parameters, null); + } + + /// + public void QueueMailBoxMigrationAsync(string AuthUserName, string AuthPassword, string[] parameters, object userState) + { + if ((this.QueueMailBoxMigrationOperationCompleted == null)) + { + this.QueueMailBoxMigrationOperationCompleted = new System.Threading.SendOrPostCallback(this.OnQueueMailBoxMigrationOperationCompleted); + } + this.InvokeAsync("QueueMailBoxMigration", new object[] { + AuthUserName, + AuthPassword, + parameters}, this.QueueMailBoxMigrationOperationCompleted, userState); + } + + private void OnQueueMailBoxMigrationOperationCompleted(object arg) + { + if ((this.QueueMailBoxMigrationCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.QueueMailBoxMigrationCompleted(this, new QueueMailBoxMigrationCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveFromMigrationQueue", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public void RemoveFromMigrationQueue(string AuthUserName, string AuthPassword, System.Guid itemID) + { + this.Invoke("RemoveFromMigrationQueue", new object[] { + AuthUserName, + AuthPassword, + itemID}); + } + + /// + public System.IAsyncResult BeginRemoveFromMigrationQueue(string AuthUserName, string AuthPassword, System.Guid itemID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveFromMigrationQueue", new object[] { + AuthUserName, + AuthPassword, + itemID}, callback, asyncState); + } + + /// + public void EndRemoveFromMigrationQueue(System.IAsyncResult asyncResult) + { + this.EndInvoke(asyncResult); + } + + /// + public void RemoveFromMigrationQueueAsync(string AuthUserName, string AuthPassword, System.Guid itemID) + { + this.RemoveFromMigrationQueueAsync(AuthUserName, AuthPassword, itemID, null); + } + + /// + public void RemoveFromMigrationQueueAsync(string AuthUserName, string AuthPassword, System.Guid itemID, object userState) + { + if ((this.RemoveFromMigrationQueueOperationCompleted == null)) + { + this.RemoveFromMigrationQueueOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveFromMigrationQueueOperationCompleted); + } + this.InvokeAsync("RemoveFromMigrationQueue", new object[] { + AuthUserName, + AuthPassword, + itemID}, this.RemoveFromMigrationQueueOperationCompleted, userState); + } + + private void OnRemoveFromMigrationQueueOperationCompleted(object arg) + { + if ((this.RemoveFromMigrationQueueCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveFromMigrationQueueCompleted(this, new System.ComponentModel.AsyncCompletedEventArgs(invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetMigrationStatus", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + [return: System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public StatusResults[] GetMigrationStatus(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetMigrationStatus", new object[] { + AuthUserName, + AuthPassword}); + return ((StatusResults[])(results[0])); + } + + /// + public System.IAsyncResult BeginGetMigrationStatus(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetMigrationStatus", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public StatusResults[] EndGetMigrationStatus(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((StatusResults[])(results[0])); + } + + /// + public void GetMigrationStatusAsync(string AuthUserName, string AuthPassword) + { + this.GetMigrationStatusAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetMigrationStatusAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetMigrationStatusOperationCompleted == null)) + { + this.GetMigrationStatusOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetMigrationStatusOperationCompleted); + } + this.InvokeAsync("GetMigrationStatus", new object[] { + AuthUserName, + AuthPassword}, this.GetMigrationStatusOperationCompleted, userState); + } + + private void OnGetMigrationStatusOperationCompleted(object arg) + { + if ((this.GetMigrationStatusCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetMigrationStatusCompleted(this, new GetMigrationStatusCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddUser(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin) + { + object[] results = this.Invoke("AddUser", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddUser(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddUser", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin}, callback, asyncState); + } + + /// + public GenericResult EndAddUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddUserAsync(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin) + { + this.AddUserAsync(AuthUserName, AuthPassword, NewUsername, NewPassword, DomainName, FirstName, LastName, IsDomainAdmin, null); + } + + /// + public void AddUserAsync(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, object userState) + { + if ((this.AddUserOperationCompleted == null)) + { + this.AddUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddUserOperationCompleted); + } + this.InvokeAsync("AddUser", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin}, this.AddUserOperationCompleted, userState); + } + + private void OnAddUserOperationCompleted(object arg) + { + if ((this.AddUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddUserCompleted(this, new AddUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddUser2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddUser2(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, int maxMailboxSize) + { + object[] results = this.Invoke("AddUser2", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin, + maxMailboxSize}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddUser2(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, int maxMailboxSize, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddUser2", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin, + maxMailboxSize}, callback, asyncState); + } + + /// + public GenericResult EndAddUser2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddUser2Async(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, int maxMailboxSize) + { + this.AddUser2Async(AuthUserName, AuthPassword, NewUsername, NewPassword, DomainName, FirstName, LastName, IsDomainAdmin, maxMailboxSize, null); + } + + /// + public void AddUser2Async(string AuthUserName, string AuthPassword, string NewUsername, string NewPassword, string DomainName, string FirstName, string LastName, bool IsDomainAdmin, int maxMailboxSize, object userState) + { + if ((this.AddUser2OperationCompleted == null)) + { + this.AddUser2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddUser2OperationCompleted); + } + this.InvokeAsync("AddUser2", new object[] { + AuthUserName, + AuthPassword, + NewUsername, + NewPassword, + DomainName, + FirstName, + LastName, + IsDomainAdmin, + maxMailboxSize}, this.AddUser2OperationCompleted, userState); + } + + private void OnAddUser2OperationCompleted(object arg) + { + if ((this.AddUser2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddUser2Completed(this, new AddUser2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AuthenticateUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AuthenticateUser(string UserName, string DomainName, string Password) + { + object[] results = this.Invoke("AuthenticateUser", new object[] { + UserName, + DomainName, + Password}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAuthenticateUser(string UserName, string DomainName, string Password, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AuthenticateUser", new object[] { + UserName, + DomainName, + Password}, callback, asyncState); + } + + /// + public GenericResult EndAuthenticateUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AuthenticateUserAsync(string UserName, string DomainName, string Password) + { + this.AuthenticateUserAsync(UserName, DomainName, Password, null); + } + + /// + public void AuthenticateUserAsync(string UserName, string DomainName, string Password, object userState) + { + if ((this.AuthenticateUserOperationCompleted == null)) + { + this.AuthenticateUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAuthenticateUserOperationCompleted); + } + this.InvokeAsync("AuthenticateUser", new object[] { + UserName, + DomainName, + Password}, this.AuthenticateUserOperationCompleted, userState); + } + + private void OnAuthenticateUserOperationCompleted(object arg) + { + if ((this.AuthenticateUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AuthenticateUserCompleted(this, new AuthenticateUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUser(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin) + { + object[] results = this.Invoke("UpdateUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUser(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUserAsync(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin) + { + this.UpdateUserAsync(AuthUserName, AuthPassword, EmailAddress, NewPassword, NewFirstName, NewLastName, IsDomainAdmin, null); + } + + /// + public void UpdateUserAsync(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, object userState) + { + if ((this.UpdateUserOperationCompleted == null)) + { + this.UpdateUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUserOperationCompleted); + } + this.InvokeAsync("UpdateUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin}, this.UpdateUserOperationCompleted, userState); + } + + private void OnUpdateUserOperationCompleted(object arg) + { + if ((this.UpdateUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUserCompleted(this, new UpdateUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUser2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUser2(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, int maxMailboxSize) + { + object[] results = this.Invoke("UpdateUser2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin, + maxMailboxSize}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUser2(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, int maxMailboxSize, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUser2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin, + maxMailboxSize}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUser2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUser2Async(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, int maxMailboxSize) + { + this.UpdateUser2Async(AuthUserName, AuthPassword, EmailAddress, NewPassword, NewFirstName, NewLastName, IsDomainAdmin, maxMailboxSize, null); + } + + /// + public void UpdateUser2Async(string AuthUserName, string AuthPassword, string EmailAddress, string NewPassword, string NewFirstName, string NewLastName, bool IsDomainAdmin, int maxMailboxSize, object userState) + { + if ((this.UpdateUser2OperationCompleted == null)) + { + this.UpdateUser2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUser2OperationCompleted); + } + this.InvokeAsync("UpdateUser2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + NewPassword, + NewFirstName, + NewLastName, + IsDomainAdmin, + maxMailboxSize}, this.UpdateUser2OperationCompleted, userState); + } + + private void OnUpdateUser2OperationCompleted(object arg) + { + if ((this.UpdateUser2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUser2Completed(this, new UpdateUser2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUserForwardingInfo", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUserForwardingInfo(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string ForwardingAddress) + { + object[] results = this.Invoke("UpdateUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUserForwardingInfo(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string ForwardingAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddress}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUserForwardingInfo(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUserForwardingInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string ForwardingAddress) + { + this.UpdateUserForwardingInfoAsync(AuthUserName, AuthPassword, EmailAddress, DeleteOnForward, ForwardingAddress, null); + } + + /// + public void UpdateUserForwardingInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string ForwardingAddress, object userState) + { + if ((this.UpdateUserForwardingInfoOperationCompleted == null)) + { + this.UpdateUserForwardingInfoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUserForwardingInfoOperationCompleted); + } + this.InvokeAsync("UpdateUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddress}, this.UpdateUserForwardingInfoOperationCompleted, userState); + } + + private void OnUpdateUserForwardingInfoOperationCompleted(object arg) + { + if ((this.UpdateUserForwardingInfoCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUserForwardingInfoCompleted(this, new UpdateUserForwardingInfoCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUserForwardingInfo2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUserForwardingInfo2(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string[] ForwardingAddresses) + { + object[] results = this.Invoke("UpdateUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddresses}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUserForwardingInfo2(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string[] ForwardingAddresses, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddresses}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUserForwardingInfo2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUserForwardingInfo2Async(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string[] ForwardingAddresses) + { + this.UpdateUserForwardingInfo2Async(AuthUserName, AuthPassword, EmailAddress, DeleteOnForward, ForwardingAddresses, null); + } + + /// + public void UpdateUserForwardingInfo2Async(string AuthUserName, string AuthPassword, string EmailAddress, bool DeleteOnForward, string[] ForwardingAddresses, object userState) + { + if ((this.UpdateUserForwardingInfo2OperationCompleted == null)) + { + this.UpdateUserForwardingInfo2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUserForwardingInfo2OperationCompleted); + } + this.InvokeAsync("UpdateUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DeleteOnForward, + ForwardingAddresses}, this.UpdateUserForwardingInfo2OperationCompleted, userState); + } + + private void OnUpdateUserForwardingInfo2OperationCompleted(object arg) + { + if ((this.UpdateUserForwardingInfo2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUserForwardingInfo2Completed(this, new UpdateUserForwardingInfo2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUserAutoResponseInfo", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUserAutoResponseInfo(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, string Subject, string Body) + { + object[] results = this.Invoke("UpdateUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled, + Subject, + Body}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUserAutoResponseInfo(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, string Subject, string Body, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled, + Subject, + Body}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUserAutoResponseInfo(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUserAutoResponseInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, string Subject, string Body) + { + this.UpdateUserAutoResponseInfoAsync(AuthUserName, AuthPassword, EmailAddress, Enabled, Subject, Body, null); + } + + /// + public void UpdateUserAutoResponseInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, string Subject, string Body, object userState) + { + if ((this.UpdateUserAutoResponseInfoOperationCompleted == null)) + { + this.UpdateUserAutoResponseInfoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUserAutoResponseInfoOperationCompleted); + } + this.InvokeAsync("UpdateUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled, + Subject, + Body}, this.UpdateUserAutoResponseInfoOperationCompleted, userState); + } + + private void OnUpdateUserAutoResponseInfoOperationCompleted(object arg) + { + if ((this.UpdateUserAutoResponseInfoCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUserAutoResponseInfoCompleted(this, new UpdateUserAutoResponseInfoCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteUser(string AuthUserName, string AuthPassword, string Username, string DomainName) + { + object[] results = this.Invoke("DeleteUser", new object[] { + AuthUserName, + AuthPassword, + Username, + DomainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteUser(string AuthUserName, string AuthPassword, string Username, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteUser", new object[] { + AuthUserName, + AuthPassword, + Username, + DomainName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteUserAsync(string AuthUserName, string AuthPassword, string Username, string DomainName) + { + this.DeleteUserAsync(AuthUserName, AuthPassword, Username, DomainName, null); + } + + /// + public void DeleteUserAsync(string AuthUserName, string AuthPassword, string Username, string DomainName, object userState) + { + if ((this.DeleteUserOperationCompleted == null)) + { + this.DeleteUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteUserOperationCompleted); + } + this.InvokeAsync("DeleteUser", new object[] { + AuthUserName, + AuthPassword, + Username, + DomainName}, this.DeleteUserOperationCompleted, userState); + } + + private void OnDeleteUserOperationCompleted(object arg) + { + if ((this.DeleteUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteUserCompleted(this, new DeleteUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserInfoResult GetUser(string AuthUserName, string AuthPassword, string EmailAddress) + { + object[] results = this.Invoke("GetUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}); + return ((UserInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUser(string AuthUserName, string AuthPassword, string EmailAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, callback, asyncState); + } + + /// + public UserInfoResult EndGetUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserInfoResult)(results[0])); + } + + /// + public void GetUserAsync(string AuthUserName, string AuthPassword, string EmailAddress) + { + this.GetUserAsync(AuthUserName, AuthPassword, EmailAddress, null); + } + + /// + public void GetUserAsync(string AuthUserName, string AuthPassword, string EmailAddress, object userState) + { + if ((this.GetUserOperationCompleted == null)) + { + this.GetUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserOperationCompleted); + } + this.InvokeAsync("GetUser", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, this.GetUserOperationCompleted, userState); + } + + private void OnGetUserOperationCompleted(object arg) + { + if ((this.GetUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserCompleted(this, new GetUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetLastLoginTimes", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public LastLoginInfoResult GetLastLoginTimes(string AuthUserName, string AuthPassword, string EmailAddress, [System.Xml.Serialization.XmlElementAttribute(IsNullable = true)] System.Nullable DateStart, [System.Xml.Serialization.XmlElementAttribute(IsNullable = true)] System.Nullable DateEnd) + { + object[] results = this.Invoke("GetLastLoginTimes", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DateStart, + DateEnd}); + return ((LastLoginInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetLastLoginTimes(string AuthUserName, string AuthPassword, string EmailAddress, System.Nullable DateStart, System.Nullable DateEnd, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetLastLoginTimes", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DateStart, + DateEnd}, callback, asyncState); + } + + /// + public LastLoginInfoResult EndGetLastLoginTimes(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((LastLoginInfoResult)(results[0])); + } + + /// + public void GetLastLoginTimesAsync(string AuthUserName, string AuthPassword, string EmailAddress, System.Nullable DateStart, System.Nullable DateEnd) + { + this.GetLastLoginTimesAsync(AuthUserName, AuthPassword, EmailAddress, DateStart, DateEnd, null); + } + + /// + public void GetLastLoginTimesAsync(string AuthUserName, string AuthPassword, string EmailAddress, System.Nullable DateStart, System.Nullable DateEnd, object userState) + { + if ((this.GetLastLoginTimesOperationCompleted == null)) + { + this.GetLastLoginTimesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetLastLoginTimesOperationCompleted); + } + this.InvokeAsync("GetLastLoginTimes", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + DateStart, + DateEnd}, this.GetLastLoginTimesOperationCompleted, userState); + } + + private void OnGetLastLoginTimesOperationCompleted(object arg) + { + if ((this.GetLastLoginTimesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetLastLoginTimesCompleted(this, new GetLastLoginTimesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetRequestedUserSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SettingsRequestResult GetRequestedUserSettings(string AuthUserName, string AuthPassword, string EmailAddress, string[] requestedSettings) + { + object[] results = this.Invoke("GetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + requestedSettings}); + return ((SettingsRequestResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetRequestedUserSettings(string AuthUserName, string AuthPassword, string EmailAddress, string[] requestedSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + requestedSettings}, callback, asyncState); + } + + /// + public SettingsRequestResult EndGetRequestedUserSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SettingsRequestResult)(results[0])); + } + + /// + public void GetRequestedUserSettingsAsync(string AuthUserName, string AuthPassword, string EmailAddress, string[] requestedSettings) + { + this.GetRequestedUserSettingsAsync(AuthUserName, AuthPassword, EmailAddress, requestedSettings, null); + } + + /// + public void GetRequestedUserSettingsAsync(string AuthUserName, string AuthPassword, string EmailAddress, string[] requestedSettings, object userState) + { + if ((this.GetRequestedUserSettingsOperationCompleted == null)) + { + this.GetRequestedUserSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRequestedUserSettingsOperationCompleted); + } + this.InvokeAsync("GetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + requestedSettings}, this.GetRequestedUserSettingsOperationCompleted, userState); + } + + private void OnGetRequestedUserSettingsOperationCompleted(object arg) + { + if ((this.GetRequestedUserSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetRequestedUserSettingsCompleted(this, new GetRequestedUserSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetRequestedUserSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetRequestedUserSettings(string AuthUserName, string AuthPassword, string EmailAddress, string[] newSettings) + { + object[] results = this.Invoke("SetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + newSettings}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetRequestedUserSettings(string AuthUserName, string AuthPassword, string EmailAddress, string[] newSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + newSettings}, callback, asyncState); + } + + /// + public GenericResult EndSetRequestedUserSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetRequestedUserSettingsAsync(string AuthUserName, string AuthPassword, string EmailAddress, string[] newSettings) + { + this.SetRequestedUserSettingsAsync(AuthUserName, AuthPassword, EmailAddress, newSettings, null); + } + + /// + public void SetRequestedUserSettingsAsync(string AuthUserName, string AuthPassword, string EmailAddress, string[] newSettings, object userState) + { + if ((this.SetRequestedUserSettingsOperationCompleted == null)) + { + this.SetRequestedUserSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRequestedUserSettingsOperationCompleted); + } + this.InvokeAsync("SetRequestedUserSettings", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + newSettings}, this.SetRequestedUserSettingsOperationCompleted, userState); + } + + private void OnSetRequestedUserSettingsOperationCompleted(object arg) + { + if ((this.SetRequestedUserSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetRequestedUserSettingsCompleted(this, new SetRequestedUserSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetInactiveUsers", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public InactiveUserResult GetInactiveUsers(string AuthUserName, string AuthPassword, System.DateTime date) + { + object[] results = this.Invoke("GetInactiveUsers", new object[] { + AuthUserName, + AuthPassword, + date}); + return ((InactiveUserResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetInactiveUsers(string AuthUserName, string AuthPassword, System.DateTime date, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetInactiveUsers", new object[] { + AuthUserName, + AuthPassword, + date}, callback, asyncState); + } + + /// + public InactiveUserResult EndGetInactiveUsers(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((InactiveUserResult)(results[0])); + } + + /// + public void GetInactiveUsersAsync(string AuthUserName, string AuthPassword, System.DateTime date) + { + this.GetInactiveUsersAsync(AuthUserName, AuthPassword, date, null); + } + + /// + public void GetInactiveUsersAsync(string AuthUserName, string AuthPassword, System.DateTime date, object userState) + { + if ((this.GetInactiveUsersOperationCompleted == null)) + { + this.GetInactiveUsersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetInactiveUsersOperationCompleted); + } + this.InvokeAsync("GetInactiveUsers", new object[] { + AuthUserName, + AuthPassword, + date}, this.GetInactiveUsersOperationCompleted, userState); + } + + private void OnGetInactiveUsersOperationCompleted(object arg) + { + if ((this.GetInactiveUsersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetInactiveUsersCompleted(this, new GetInactiveUsersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserForwardingInfo2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserForwardingInfoResult2 GetUserForwardingInfo2(string AuthUserName, string AuthPassword, string EmailAddress) + { + object[] results = this.Invoke("GetUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}); + return ((UserForwardingInfoResult2)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserForwardingInfo2(string AuthUserName, string AuthPassword, string EmailAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, callback, asyncState); + } + + /// + public UserForwardingInfoResult2 EndGetUserForwardingInfo2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserForwardingInfoResult2)(results[0])); + } + + /// + public void GetUserForwardingInfo2Async(string AuthUserName, string AuthPassword, string EmailAddress) + { + this.GetUserForwardingInfo2Async(AuthUserName, AuthPassword, EmailAddress, null); + } + + /// + public void GetUserForwardingInfo2Async(string AuthUserName, string AuthPassword, string EmailAddress, object userState) + { + if ((this.GetUserForwardingInfo2OperationCompleted == null)) + { + this.GetUserForwardingInfo2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserForwardingInfo2OperationCompleted); + } + this.InvokeAsync("GetUserForwardingInfo2", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, this.GetUserForwardingInfo2OperationCompleted, userState); + } + + private void OnGetUserForwardingInfo2OperationCompleted(object arg) + { + if ((this.GetUserForwardingInfo2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserForwardingInfo2Completed(this, new GetUserForwardingInfo2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserForwardingInfo", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserForwardingInfoResult GetUserForwardingInfo(string AuthUserName, string AuthPassword, string EmailAddress) + { + object[] results = this.Invoke("GetUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}); + return ((UserForwardingInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserForwardingInfo(string AuthUserName, string AuthPassword, string EmailAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, callback, asyncState); + } + + /// + public UserForwardingInfoResult EndGetUserForwardingInfo(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserForwardingInfoResult)(results[0])); + } + + /// + public void GetUserForwardingInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress) + { + this.GetUserForwardingInfoAsync(AuthUserName, AuthPassword, EmailAddress, null); + } + + /// + public void GetUserForwardingInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, object userState) + { + if ((this.GetUserForwardingInfoOperationCompleted == null)) + { + this.GetUserForwardingInfoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserForwardingInfoOperationCompleted); + } + this.InvokeAsync("GetUserForwardingInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, this.GetUserForwardingInfoOperationCompleted, userState); + } + + private void OnGetUserForwardingInfoOperationCompleted(object arg) + { + if ((this.GetUserForwardingInfoCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserForwardingInfoCompleted(this, new GetUserForwardingInfoCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserAutoResponseInfo", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserAutoResponseResult GetUserAutoResponseInfo(string AuthUserName, string AuthPassword, string EmailAddress) + { + object[] results = this.Invoke("GetUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}); + return ((UserAutoResponseResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserAutoResponseInfo(string AuthUserName, string AuthPassword, string EmailAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, callback, asyncState); + } + + /// + public UserAutoResponseResult EndGetUserAutoResponseInfo(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserAutoResponseResult)(results[0])); + } + + /// + public void GetUserAutoResponseInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress) + { + this.GetUserAutoResponseInfoAsync(AuthUserName, AuthPassword, EmailAddress, null); + } + + /// + public void GetUserAutoResponseInfoAsync(string AuthUserName, string AuthPassword, string EmailAddress, object userState) + { + if ((this.GetUserAutoResponseInfoOperationCompleted == null)) + { + this.GetUserAutoResponseInfoOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserAutoResponseInfoOperationCompleted); + } + this.InvokeAsync("GetUserAutoResponseInfo", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, this.GetUserAutoResponseInfoOperationCompleted, userState); + } + + private void OnGetUserAutoResponseInfoOperationCompleted(object arg) + { + if ((this.GetUserAutoResponseInfoCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserAutoResponseInfoCompleted(this, new GetUserAutoResponseInfoCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserQuotas", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public QuotaInfoListResult GetUserQuotas(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetUserQuotas", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((QuotaInfoListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserQuotas(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserQuotas", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public QuotaInfoListResult EndGetUserQuotas(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((QuotaInfoListResult)(results[0])); + } + + /// + public void GetUserQuotasAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetUserQuotasAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetUserQuotasAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetUserQuotasOperationCompleted == null)) + { + this.GetUserQuotasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserQuotasOperationCompleted); + } + this.InvokeAsync("GetUserQuotas", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetUserQuotasOperationCompleted, userState); + } + + private void OnGetUserQuotasOperationCompleted(object arg) + { + if ((this.GetUserQuotasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserQuotasCompleted(this, new GetUserQuotasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUsers", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserInfoListResult GetUsers(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((UserInfoListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUsers(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public UserInfoListResult EndGetUsers(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserInfoListResult)(results[0])); + } + + /// + public void GetUsersAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetUsersAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetUsersAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetUsersOperationCompleted == null)) + { + this.GetUsersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUsersOperationCompleted); + } + this.InvokeAsync("GetUsers", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetUsersOperationCompleted, userState); + } + + private void OnGetUsersOperationCompleted(object arg) + { + if ((this.GetUsersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUsersCompleted(this, new GetUsersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/LoginValidated", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public LoginResult LoginValidated(string Username, string Password) + { + object[] results = this.Invoke("LoginValidated", new object[] { + Username, + Password}); + return ((LoginResult)(results[0])); + } + + /// + public System.IAsyncResult BeginLoginValidated(string Username, string Password, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("LoginValidated", new object[] { + Username, + Password}, callback, asyncState); + } + + /// + public LoginResult EndLoginValidated(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((LoginResult)(results[0])); + } + + /// + public void LoginValidatedAsync(string Username, string Password) + { + this.LoginValidatedAsync(Username, Password, null); + } + + /// + public void LoginValidatedAsync(string Username, string Password, object userState) + { + if ((this.LoginValidatedOperationCompleted == null)) + { + this.LoginValidatedOperationCompleted = new System.Threading.SendOrPostCallback(this.OnLoginValidatedOperationCompleted); + } + this.InvokeAsync("LoginValidated", new object[] { + Username, + Password}, this.LoginValidatedOperationCompleted, userState); + } + + private void OnLoginValidatedOperationCompleted(object arg) + { + if ((this.LoginValidatedCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.LoginValidatedCompleted(this, new LoginValidatedCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddRSSFeed", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddRSSFeed(string AuthUserName, string AuthPassword, string EmailAddress, string rssUrl, string rssName, string rssFolder) + { + object[] results = this.Invoke("AddRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + rssUrl, + rssName, + rssFolder}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddRSSFeed(string AuthUserName, string AuthPassword, string EmailAddress, string rssUrl, string rssName, string rssFolder, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + rssUrl, + rssName, + rssFolder}, callback, asyncState); + } + + /// + public GenericResult EndAddRSSFeed(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddRSSFeedAsync(string AuthUserName, string AuthPassword, string EmailAddress, string rssUrl, string rssName, string rssFolder) + { + this.AddRSSFeedAsync(AuthUserName, AuthPassword, EmailAddress, rssUrl, rssName, rssFolder, null); + } + + /// + public void AddRSSFeedAsync(string AuthUserName, string AuthPassword, string EmailAddress, string rssUrl, string rssName, string rssFolder, object userState) + { + if ((this.AddRSSFeedOperationCompleted == null)) + { + this.AddRSSFeedOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddRSSFeedOperationCompleted); + } + this.InvokeAsync("AddRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + rssUrl, + rssName, + rssFolder}, this.AddRSSFeedOperationCompleted, userState); + } + + private void OnAddRSSFeedOperationCompleted(object arg) + { + if ((this.AddRSSFeedCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddRSSFeedCompleted(this, new AddRSSFeedCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ToggleActiveSync", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult ToggleActiveSync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled) + { + object[] results = this.Invoke("ToggleActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginToggleActiveSync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ToggleActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}, callback, asyncState); + } + + /// + public GenericResult EndToggleActiveSync(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void ToggleActiveSyncAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled) + { + this.ToggleActiveSyncAsync(AuthUserName, AuthPassword, EmailAddress, Enabled, null); + } + + /// + public void ToggleActiveSyncAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, object userState) + { + if ((this.ToggleActiveSyncOperationCompleted == null)) + { + this.ToggleActiveSyncOperationCompleted = new System.Threading.SendOrPostCallback(this.OnToggleActiveSyncOperationCompleted); + } + this.InvokeAsync("ToggleActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}, this.ToggleActiveSyncOperationCompleted, userState); + } + + private void OnToggleActiveSyncOperationCompleted(object arg) + { + if ((this.ToggleActiveSyncCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ToggleActiveSyncCompleted(this, new ToggleActiveSyncCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/IsUserEnabledForActiveSync", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public ActiveSyncEnabledResult IsUserEnabledForActiveSync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled) + { + object[] results = this.Invoke("IsUserEnabledForActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}); + return ((ActiveSyncEnabledResult)(results[0])); + } + + /// + public System.IAsyncResult BeginIsUserEnabledForActiveSync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("IsUserEnabledForActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}, callback, asyncState); + } + + /// + public ActiveSyncEnabledResult EndIsUserEnabledForActiveSync(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((ActiveSyncEnabledResult)(results[0])); + } + + /// + public void IsUserEnabledForActiveSyncAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled) + { + this.IsUserEnabledForActiveSyncAsync(AuthUserName, AuthPassword, EmailAddress, Enabled, null); + } + + /// + public void IsUserEnabledForActiveSyncAsync(string AuthUserName, string AuthPassword, string EmailAddress, bool Enabled, object userState) + { + if ((this.IsUserEnabledForActiveSyncOperationCompleted == null)) + { + this.IsUserEnabledForActiveSyncOperationCompleted = new System.Threading.SendOrPostCallback(this.OnIsUserEnabledForActiveSyncOperationCompleted); + } + this.InvokeAsync("IsUserEnabledForActiveSync", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Enabled}, this.IsUserEnabledForActiveSyncOperationCompleted, userState); + } + + private void OnIsUserEnabledForActiveSyncOperationCompleted(object arg) + { + if ((this.IsUserEnabledForActiveSyncCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.IsUserEnabledForActiveSyncCompleted(this, new IsUserEnabledForActiveSyncCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListRSSFeeds", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public RSSFeedListResult ListRSSFeeds(string AuthUserName, string AuthPassword, string EmailAddress) + { + object[] results = this.Invoke("ListRSSFeeds", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}); + return ((RSSFeedListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListRSSFeeds(string AuthUserName, string AuthPassword, string EmailAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListRSSFeeds", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, callback, asyncState); + } + + /// + public RSSFeedListResult EndListRSSFeeds(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((RSSFeedListResult)(results[0])); + } + + /// + public void ListRSSFeedsAsync(string AuthUserName, string AuthPassword, string EmailAddress) + { + this.ListRSSFeedsAsync(AuthUserName, AuthPassword, EmailAddress, null); + } + + /// + public void ListRSSFeedsAsync(string AuthUserName, string AuthPassword, string EmailAddress, object userState) + { + if ((this.ListRSSFeedsOperationCompleted == null)) + { + this.ListRSSFeedsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListRSSFeedsOperationCompleted); + } + this.InvokeAsync("ListRSSFeeds", new object[] { + AuthUserName, + AuthPassword, + EmailAddress}, this.ListRSSFeedsOperationCompleted, userState); + } + + private void OnListRSSFeedsOperationCompleted(object arg) + { + if ((this.ListRSSFeedsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListRSSFeedsCompleted(this, new ListRSSFeedsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteRSSFeed", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteRSSFeed(string AuthUserName, string AuthPassword, string EmailAddress, string UID) + { + object[] results = this.Invoke("DeleteRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + UID}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteRSSFeed(string AuthUserName, string AuthPassword, string EmailAddress, string UID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + UID}, callback, asyncState); + } + + /// + public GenericResult EndDeleteRSSFeed(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteRSSFeedAsync(string AuthUserName, string AuthPassword, string EmailAddress, string UID) + { + this.DeleteRSSFeedAsync(AuthUserName, AuthPassword, EmailAddress, UID, null); + } + + /// + public void DeleteRSSFeedAsync(string AuthUserName, string AuthPassword, string EmailAddress, string UID, object userState) + { + if ((this.DeleteRSSFeedOperationCompleted == null)) + { + this.DeleteRSSFeedOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteRSSFeedOperationCompleted); + } + this.InvokeAsync("DeleteRSSFeed", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + UID}, this.DeleteRSSFeedOperationCompleted, userState); + } + + private void OnDeleteRSSFeedOperationCompleted(object arg) + { + if ((this.DeleteRSSFeedCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteRSSFeedCompleted(this, new DeleteRSSFeedCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserStats", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public StatInfoResult GetUserStats(string AuthUserName, string AuthPassword, string EmailAddress, System.DateTime Start, System.DateTime End) + { + object[] results = this.Invoke("GetUserStats", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Start, + End}); + return ((StatInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserStats(string AuthUserName, string AuthPassword, string EmailAddress, System.DateTime Start, System.DateTime End, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserStats", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Start, + End}, callback, asyncState); + } + + /// + public StatInfoResult EndGetUserStats(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((StatInfoResult)(results[0])); + } + + /// + public void GetUserStatsAsync(string AuthUserName, string AuthPassword, string EmailAddress, System.DateTime Start, System.DateTime End) + { + this.GetUserStatsAsync(AuthUserName, AuthPassword, EmailAddress, Start, End, null); + } + + /// + public void GetUserStatsAsync(string AuthUserName, string AuthPassword, string EmailAddress, System.DateTime Start, System.DateTime End, object userState) + { + if ((this.GetUserStatsOperationCompleted == null)) + { + this.GetUserStatsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserStatsOperationCompleted); + } + this.InvokeAsync("GetUserStats", new object[] { + AuthUserName, + AuthPassword, + EmailAddress, + Start, + End}, this.GetUserStatsOperationCompleted, userState); + } + + private void OnGetUserStatsOperationCompleted(object arg) + { + if ((this.GetUserStatsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserStatsCompleted(this, new GetUserStatsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddUserGroup", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupName, string[] UserNames) + { + object[] results = this.Invoke("AddUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupName, + UserNames}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupName, string[] UserNames, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupName, + UserNames}, callback, asyncState); + } + + /// + public GenericResult EndAddUserGroup(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupName, string[] UserNames) + { + this.AddUserGroupAsync(AuthUserName, AuthPassword, DomainName, UserGroupName, UserNames, null); + } + + /// + public void AddUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupName, string[] UserNames, object userState) + { + if ((this.AddUserGroupOperationCompleted == null)) + { + this.AddUserGroupOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddUserGroupOperationCompleted); + } + this.InvokeAsync("AddUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupName, + UserNames}, this.AddUserGroupOperationCompleted, userState); + } + + private void OnAddUserGroupOperationCompleted(object arg) + { + if ((this.AddUserGroupCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddUserGroupCompleted(this, new AddUserGroupCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveUserGroup", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID) + { + object[] results = this.Invoke("RemoveUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}, callback, asyncState); + } + + /// + public GenericResult EndRemoveUserGroup(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID) + { + this.RemoveUserGroupAsync(AuthUserName, AuthPassword, DomainName, UserGroupID, null); + } + + /// + public void RemoveUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, object userState) + { + if ((this.RemoveUserGroupOperationCompleted == null)) + { + this.RemoveUserGroupOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveUserGroupOperationCompleted); + } + this.InvokeAsync("RemoveUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}, this.RemoveUserGroupOperationCompleted, userState); + } + + private void OnRemoveUserGroupOperationCompleted(object arg) + { + if ((this.RemoveUserGroupCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveUserGroupCompleted(this, new RemoveUserGroupCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateUserGroup", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, string UserGroupName, string[] UserNames) + { + object[] results = this.Invoke("UpdateUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID, + UserGroupName, + UserNames}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, string UserGroupName, string[] UserNames, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID, + UserGroupName, + UserNames}, callback, asyncState); + } + + /// + public GenericResult EndUpdateUserGroup(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, string UserGroupName, string[] UserNames) + { + this.UpdateUserGroupAsync(AuthUserName, AuthPassword, DomainName, UserGroupID, UserGroupName, UserNames, null); + } + + /// + public void UpdateUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, string UserGroupName, string[] UserNames, object userState) + { + if ((this.UpdateUserGroupOperationCompleted == null)) + { + this.UpdateUserGroupOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateUserGroupOperationCompleted); + } + this.InvokeAsync("UpdateUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID, + UserGroupName, + UserNames}, this.UpdateUserGroupOperationCompleted, userState); + } + + private void OnUpdateUserGroupOperationCompleted(object arg) + { + if ((this.UpdateUserGroupCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateUserGroupCompleted(this, new UpdateUserGroupCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserGroup", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserGroupInfoResult GetUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID) + { + object[] results = this.Invoke("GetUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}); + return ((UserGroupInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserGroup(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}, callback, asyncState); + } + + /// + public UserGroupInfoResult EndGetUserGroup(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserGroupInfoResult)(results[0])); + } + + /// + public void GetUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID) + { + this.GetUserGroupAsync(AuthUserName, AuthPassword, DomainName, UserGroupID, null); + } + + /// + public void GetUserGroupAsync(string AuthUserName, string AuthPassword, string DomainName, string UserGroupID, object userState) + { + if ((this.GetUserGroupOperationCompleted == null)) + { + this.GetUserGroupOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserGroupOperationCompleted); + } + this.InvokeAsync("GetUserGroup", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserGroupID}, this.GetUserGroupOperationCompleted, userState); + } + + private void OnGetUserGroupOperationCompleted(object arg) + { + if ((this.GetUserGroupCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserGroupCompleted(this, new GetUserGroupCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserGroupsByUser", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserGroupsResult GetUserGroupsByUser(string AuthUserName, string AuthPassword, string DomainName, string UserName, bool IncludeUserNames) + { + object[] results = this.Invoke("GetUserGroupsByUser", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserName, + IncludeUserNames}); + return ((UserGroupsResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserGroupsByUser(string AuthUserName, string AuthPassword, string DomainName, string UserName, bool IncludeUserNames, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserGroupsByUser", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserName, + IncludeUserNames}, callback, asyncState); + } + + /// + public UserGroupsResult EndGetUserGroupsByUser(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserGroupsResult)(results[0])); + } + + /// + public void GetUserGroupsByUserAsync(string AuthUserName, string AuthPassword, string DomainName, string UserName, bool IncludeUserNames) + { + this.GetUserGroupsByUserAsync(AuthUserName, AuthPassword, DomainName, UserName, IncludeUserNames, null); + } + + /// + public void GetUserGroupsByUserAsync(string AuthUserName, string AuthPassword, string DomainName, string UserName, bool IncludeUserNames, object userState) + { + if ((this.GetUserGroupsByUserOperationCompleted == null)) + { + this.GetUserGroupsByUserOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserGroupsByUserOperationCompleted); + } + this.InvokeAsync("GetUserGroupsByUser", new object[] { + AuthUserName, + AuthPassword, + DomainName, + UserName, + IncludeUserNames}, this.GetUserGroupsByUserOperationCompleted, userState); + } + + private void OnGetUserGroupsByUserOperationCompleted(object arg) + { + if ((this.GetUserGroupsByUserCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserGroupsByUserCompleted(this, new GetUserGroupsByUserCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetUserGroupsByDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public UserGroupsResult GetUserGroupsByDomain(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetUserGroupsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((UserGroupsResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetUserGroupsByDomain(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetUserGroupsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public UserGroupsResult EndGetUserGroupsByDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((UserGroupsResult)(results[0])); + } + + /// + public void GetUserGroupsByDomainAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetUserGroupsByDomainAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetUserGroupsByDomainAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetUserGroupsByDomainOperationCompleted == null)) + { + this.GetUserGroupsByDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetUserGroupsByDomainOperationCompleted); + } + this.InvokeAsync("GetUserGroupsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetUserGroupsByDomainOperationCompleted, userState); + } + + private void OnGetUserGroupsByDomainOperationCompleted(object arg) + { + if ((this.GetUserGroupsByDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetUserGroupsByDomainCompleted(this, new GetUserGroupsByDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class RequestStatusResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] keyValuePairsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] KeyValuePairs + { + get + { + return this.keyValuePairsField; + } + set + { + this.keyValuePairsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserGroupsResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private UserGroupInfo[] userGroupsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public UserGroupInfo[] UserGroups + { + get + { + return this.userGroupsField; + } + set + { + this.userGroupsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserGroupInfo + { + + private string guidField; + + private string nameField; + + private string[] userNamesField; + + /// + public string guid + { + get + { + return this.guidField; + } + set + { + this.guidField = value; + } + } + + /// + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public string[] userNames + { + get + { + return this.userNamesField; + } + set + { + this.userNamesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserGroupInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private UserGroupInfo userGroupField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public UserGroupInfo UserGroup + { + get + { + return this.userGroupField; + } + set + { + this.userGroupField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class RSSFeed + { + private string uidField; + + private string nameField; + + private string urlField; + + private string folderField; + + /// + public string uid + { + get + { + return this.uidField; + } + set + { + this.uidField = value; + } + } + + /// + public string name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public string url + { + get + { + return this.urlField; + } + set + { + this.urlField = value; + } + } + + /// + public string folder + { + get + { + return this.folderField; + } + set + { + this.folderField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class RSSFeedListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private RSSFeed[] rSSFeedsField; + + private string[] foldersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public RSSFeed[] RSSFeeds + { + get + { + return this.rSSFeedsField; + } + set + { + this.rSSFeedsField = value; + } + } + + /// + public string[] Folders + { + get + { + return this.foldersField; + } + set + { + this.foldersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class ActiveSyncEnabledResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private bool enabledField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public bool Enabled + { + get + { + return this.enabledField; + } + set + { + this.enabledField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class LoginResult + { + + private bool loginValidatedField; + + private int resultCodeField; + + private string messageField; + + /// + public bool LoginValidated + { + get + { + return this.loginValidatedField; + } + set + { + this.loginValidatedField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserInfoListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private UserInfo[] usersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public UserInfo[] Users + { + get + { + return this.usersField; + } + set + { + this.usersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserInfo + { + + private string userNameField; + + private string passwordField; + + private string firstNameField; + + private string lastNameField; + + private bool isSystemAdminField; + + private bool isDomainAdminField; + + /// + public string UserName + { + get + { + return this.userNameField; + } + set + { + this.userNameField = value; + } + } + + /// + public string Password + { + get + { + return this.passwordField; + } + set + { + this.passwordField = value; + } + } + + /// + public string FirstName + { + get + { + return this.firstNameField; + } + set + { + this.firstNameField = value; + } + } + + /// + public string LastName + { + get + { + return this.lastNameField; + } + set + { + this.lastNameField = value; + } + } + + /// + public bool IsSystemAdmin + { + get + { + return this.isSystemAdminField; + } + set + { + this.isSystemAdminField = value; + } + } + + /// + public bool IsDomainAdmin + { + get + { + return this.isDomainAdminField; + } + set + { + this.isDomainAdminField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserQuota + { + + private string userNameField; + + private long maxSpaceField; + + private long currentSpaceField; + + /// + public string UserName + { + get + { + return this.userNameField; + } + set + { + this.userNameField = value; + } + } + + /// + public long MaxSpace + { + get + { + return this.maxSpaceField; + } + set + { + this.maxSpaceField = value; + } + } + + /// + public long CurrentSpace + { + get + { + return this.currentSpaceField; + } + set + { + this.currentSpaceField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class QuotaInfoListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private UserQuota[] usersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public UserQuota[] Users + { + get + { + return this.usersField; + } + set + { + this.usersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserAutoResponseResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private bool enabledField; + + private string subjectField; + + private string bodyField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public bool Enabled + { + get + { + return this.enabledField; + } + set + { + this.enabledField = value; + } + } + + /// + public string Subject + { + get + { + return this.subjectField; + } + set + { + this.subjectField = value; + } + } + + /// + public string Body + { + get + { + return this.bodyField; + } + set + { + this.bodyField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserForwardingInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private bool deleteOnForwardField; + + private string forwardingAddressField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public bool DeleteOnForward + { + get + { + return this.deleteOnForwardField; + } + set + { + this.deleteOnForwardField = value; + } + } + + /// + public string ForwardingAddress + { + get + { + return this.forwardingAddressField; + } + set + { + this.forwardingAddressField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserForwardingInfoResult2 + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private bool deleteOnForwardField; + + private string[] forwardingAddressesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public bool DeleteOnForward + { + get + { + return this.deleteOnForwardField; + } + set + { + this.deleteOnForwardField = value; + } + } + + /// + public string[] ForwardingAddresses + { + get + { + return this.forwardingAddressesField; + } + set + { + this.forwardingAddressesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class InactiveUserResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] emailAddressField; + + private System.DateTime[] lastLoginField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] EmailAddress + { + get + { + return this.emailAddressField; + } + set + { + this.emailAddressField = value; + } + } + + /// + public System.DateTime[] LastLogin + { + get + { + return this.lastLoginField; + } + set + { + this.lastLoginField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserLoginInfo + { + + private string userNameField; + + private System.DateTime loginTimeField; + + /// + public string UserName + { + get + { + return this.userNameField; + } + set + { + this.userNameField = value; + } + } + + /// + public System.DateTime LoginTime + { + get + { + return this.loginTimeField; + } + set + { + this.loginTimeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class LastLoginInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] lastLoginsField; + + private UserLoginInfo[] lastUserLoginsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] lastLogins + { + get + { + return this.lastLoginsField; + } + set + { + this.lastLoginsField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public UserLoginInfo[] lastUserLogins + { + get + { + return this.lastUserLoginsField; + } + set + { + this.lastUserLoginsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class UserInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private UserInfo userInfoField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public UserInfo UserInfo + { + get + { + return this.userInfoField; + } + set + { + this.userInfoField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class StatusResults + { + + private System.Guid idField; + + private string emailAddressField; + + private string statusField; + + /// + public System.Guid ID + { + get + { + return this.idField; + } + set + { + this.idField = value; + } + } + + /// + public string emailAddress + { + get + { + return this.emailAddressField; + } + set + { + this.emailAddressField = value; + } + } + + /// + public string status + { + get + { + return this.statusField; + } + set + { + this.statusField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void QueueMailBoxMigrationCompletedEventHandler(object sender, QueueMailBoxMigrationCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class QueueMailBoxMigrationCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal QueueMailBoxMigrationCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public RequestStatusResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((RequestStatusResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveFromMigrationQueueCompletedEventHandler(object sender, System.ComponentModel.AsyncCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetMigrationStatusCompletedEventHandler(object sender, GetMigrationStatusCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetMigrationStatusCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetMigrationStatusCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public StatusResults[] Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((StatusResults[])(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddUserCompletedEventHandler(object sender, AddUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddUser2CompletedEventHandler(object sender, AddUser2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddUser2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddUser2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AuthenticateUserCompletedEventHandler(object sender, AuthenticateUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AuthenticateUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AuthenticateUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUserCompletedEventHandler(object sender, UpdateUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUser2CompletedEventHandler(object sender, UpdateUser2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUser2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUser2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUserForwardingInfoCompletedEventHandler(object sender, UpdateUserForwardingInfoCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUserForwardingInfoCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUserForwardingInfoCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUserForwardingInfo2CompletedEventHandler(object sender, UpdateUserForwardingInfo2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUserForwardingInfo2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUserForwardingInfo2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUserAutoResponseInfoCompletedEventHandler(object sender, UpdateUserAutoResponseInfoCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUserAutoResponseInfoCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUserAutoResponseInfoCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteUserCompletedEventHandler(object sender, DeleteUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserCompletedEventHandler(object sender, GetUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetLastLoginTimesCompletedEventHandler(object sender, GetLastLoginTimesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetLastLoginTimesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetLastLoginTimesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public LastLoginInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((LastLoginInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetRequestedUserSettingsCompletedEventHandler(object sender, GetRequestedUserSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetRequestedUserSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetRequestedUserSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SettingsRequestResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SettingsRequestResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetRequestedUserSettingsCompletedEventHandler(object sender, SetRequestedUserSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetRequestedUserSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetRequestedUserSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetInactiveUsersCompletedEventHandler(object sender, GetInactiveUsersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetInactiveUsersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetInactiveUsersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public InactiveUserResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((InactiveUserResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserForwardingInfo2CompletedEventHandler(object sender, GetUserForwardingInfo2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserForwardingInfo2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserForwardingInfo2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserForwardingInfoResult2 Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserForwardingInfoResult2)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserForwardingInfoCompletedEventHandler(object sender, GetUserForwardingInfoCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserForwardingInfoCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserForwardingInfoCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserForwardingInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserForwardingInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserAutoResponseInfoCompletedEventHandler(object sender, GetUserAutoResponseInfoCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserAutoResponseInfoCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserAutoResponseInfoCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserAutoResponseResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserAutoResponseResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserQuotasCompletedEventHandler(object sender, GetUserQuotasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserQuotasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserQuotasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public QuotaInfoListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((QuotaInfoListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUsersCompletedEventHandler(object sender, GetUsersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUsersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUsersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserInfoListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserInfoListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void LoginValidatedCompletedEventHandler(object sender, LoginValidatedCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class LoginValidatedCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal LoginValidatedCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public LoginResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((LoginResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddRSSFeedCompletedEventHandler(object sender, AddRSSFeedCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddRSSFeedCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddRSSFeedCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ToggleActiveSyncCompletedEventHandler(object sender, ToggleActiveSyncCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ToggleActiveSyncCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ToggleActiveSyncCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void IsUserEnabledForActiveSyncCompletedEventHandler(object sender, IsUserEnabledForActiveSyncCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class IsUserEnabledForActiveSyncCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal IsUserEnabledForActiveSyncCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public ActiveSyncEnabledResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((ActiveSyncEnabledResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListRSSFeedsCompletedEventHandler(object sender, ListRSSFeedsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListRSSFeedsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListRSSFeedsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public RSSFeedListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((RSSFeedListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteRSSFeedCompletedEventHandler(object sender, DeleteRSSFeedCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteRSSFeedCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteRSSFeedCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserStatsCompletedEventHandler(object sender, GetUserStatsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserStatsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserStatsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public StatInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((StatInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddUserGroupCompletedEventHandler(object sender, AddUserGroupCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddUserGroupCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddUserGroupCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveUserGroupCompletedEventHandler(object sender, RemoveUserGroupCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveUserGroupCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveUserGroupCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateUserGroupCompletedEventHandler(object sender, UpdateUserGroupCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateUserGroupCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateUserGroupCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserGroupCompletedEventHandler(object sender, GetUserGroupCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserGroupCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserGroupCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserGroupInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserGroupInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserGroupsByUserCompletedEventHandler(object sender, GetUserGroupsByUserCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserGroupsByUserCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserGroupsByUserCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserGroupsResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserGroupsResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetUserGroupsByDomainCompletedEventHandler(object sender, GetUserGroupsByDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetUserGroupsByDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetUserGroupsByDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public UserGroupsResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((UserGroupsResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcAliasAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcAliasAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback AddAliasOperationCompleted; + + private System.Threading.SendOrPostCallback SetCatchAllOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateAliasOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteAliasOperationCompleted; + + private System.Threading.SendOrPostCallback GetAliasOperationCompleted; + + private System.Threading.SendOrPostCallback GetAliasesOperationCompleted; + + /// + public svcAliasAdmin() + { + this.Url = "http://127.0.0.1:9998/Services/svcAliasAdmin.asmx"; + } + + /// + public event AddAliasCompletedEventHandler AddAliasCompleted; + + /// + public event SetCatchAllCompletedEventHandler SetCatchAllCompleted; + + /// + public event UpdateAliasCompletedEventHandler UpdateAliasCompleted; + + /// + public event DeleteAliasCompletedEventHandler DeleteAliasCompleted; + + /// + public event GetAliasCompletedEventHandler GetAliasCompleted; + + /// + public event GetAliasesCompletedEventHandler GetAliasesCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses) + { + object[] results = this.Invoke("AddAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}, callback, asyncState); + } + + /// + public GenericResult EndAddAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses) + { + this.AddAliasAsync(AuthUserName, AuthPassword, DomainName, AliasName, Addresses, null); + } + + /// + public void AddAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses, object userState) + { + if ((this.AddAliasOperationCompleted == null)) + { + this.AddAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddAliasOperationCompleted); + } + this.InvokeAsync("AddAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}, this.AddAliasOperationCompleted, userState); + } + + private void OnAddAliasOperationCompleted(object arg) + { + if ((this.AddAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddAliasCompleted(this, new AddAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetCatchAll", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetCatchAll(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + object[] results = this.Invoke("SetCatchAll", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetCatchAll(string AuthUserName, string AuthPassword, string DomainName, string AliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetCatchAll", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, callback, asyncState); + } + + /// + public GenericResult EndSetCatchAll(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetCatchAllAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + this.SetCatchAllAsync(AuthUserName, AuthPassword, DomainName, AliasName, null); + } + + /// + public void SetCatchAllAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, object userState) + { + if ((this.SetCatchAllOperationCompleted == null)) + { + this.SetCatchAllOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetCatchAllOperationCompleted); + } + this.InvokeAsync("SetCatchAll", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, this.SetCatchAllOperationCompleted, userState); + } + + private void OnSetCatchAllOperationCompleted(object arg) + { + if ((this.SetCatchAllCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetCatchAllCompleted(this, new SetCatchAllCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses) + { + object[] results = this.Invoke("UpdateAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}, callback, asyncState); + } + + /// + public GenericResult EndUpdateAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses) + { + this.UpdateAliasAsync(AuthUserName, AuthPassword, DomainName, AliasName, Addresses, null); + } + + /// + public void UpdateAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, string[] Addresses, object userState) + { + if ((this.UpdateAliasOperationCompleted == null)) + { + this.UpdateAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateAliasOperationCompleted); + } + this.InvokeAsync("UpdateAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName, + Addresses}, this.UpdateAliasOperationCompleted, userState); + } + + private void OnUpdateAliasOperationCompleted(object arg) + { + if ((this.UpdateAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateAliasCompleted(this, new UpdateAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + object[] results = this.Invoke("DeleteAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + this.DeleteAliasAsync(AuthUserName, AuthPassword, DomainName, AliasName, null); + } + + /// + public void DeleteAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, object userState) + { + if ((this.DeleteAliasOperationCompleted == null)) + { + this.DeleteAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteAliasOperationCompleted); + } + this.InvokeAsync("DeleteAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, this.DeleteAliasOperationCompleted, userState); + } + + private void OnDeleteAliasOperationCompleted(object arg) + { + if ((this.DeleteAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteAliasCompleted(this, new DeleteAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public AliasInfoResult GetAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + object[] results = this.Invoke("GetAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}); + return ((AliasInfoResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAlias(string AuthUserName, string AuthPassword, string DomainName, string AliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, callback, asyncState); + } + + /// + public AliasInfoResult EndGetAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((AliasInfoResult)(results[0])); + } + + /// + public void GetAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName) + { + this.GetAliasAsync(AuthUserName, AuthPassword, DomainName, AliasName, null); + } + + /// + public void GetAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string AliasName, object userState) + { + if ((this.GetAliasOperationCompleted == null)) + { + this.GetAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAliasOperationCompleted); + } + this.InvokeAsync("GetAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + AliasName}, this.GetAliasOperationCompleted, userState); + } + + private void OnGetAliasOperationCompleted(object arg) + { + if ((this.GetAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAliasCompleted(this, new GetAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAliases", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public AliasInfoListResult GetAliases(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((AliasInfoListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAliases(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public AliasInfoListResult EndGetAliases(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((AliasInfoListResult)(results[0])); + } + + /// + public void GetAliasesAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetAliasesAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetAliasesAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetAliasesOperationCompleted == null)) + { + this.GetAliasesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAliasesOperationCompleted); + } + this.InvokeAsync("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetAliasesOperationCompleted, userState); + } + + private void OnGetAliasesOperationCompleted(object arg) + { + if ((this.GetAliasesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAliasesCompleted(this, new GetAliasesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class AliasInfoListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private AliasInfo[] aliasInfosField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public AliasInfo[] AliasInfos + { + get + { + return this.aliasInfosField; + } + set + { + this.aliasInfosField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class AliasInfo + { + + private string nameField; + + private string[] addressesField; + + /// + public string Name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public string[] Addresses + { + get + { + return this.addressesField; + } + set + { + this.addressesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class AliasInfoResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private AliasInfo aliasInfoField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public AliasInfo AliasInfo + { + get + { + return this.aliasInfoField; + } + set + { + this.aliasInfoField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddAliasCompletedEventHandler(object sender, AddAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetCatchAllCompletedEventHandler(object sender, SetCatchAllCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetCatchAllCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetCatchAllCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateAliasCompletedEventHandler(object sender, UpdateAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteAliasCompletedEventHandler(object sender, DeleteAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetAliasCompletedEventHandler(object sender, GetAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public AliasInfoResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((AliasInfoResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetAliasesCompletedEventHandler(object sender, GetAliasesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetAliasesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetAliasesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public AliasInfoListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((AliasInfoListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcMailListAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcMailListAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback SetRequestedListSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedListSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetMailingListsByDomainOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteAllListsOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteListOperationCompleted; + + private System.Threading.SendOrPostCallback GetListCommandAddressOperationCompleted; + + private System.Threading.SendOrPostCallback SetListCommandAddressOperationCompleted; + + private System.Threading.SendOrPostCallback AddListOperationCompleted; + + private System.Threading.SendOrPostCallback AddSubscriberOperationCompleted; + + private System.Threading.SendOrPostCallback AddSubscriber2OperationCompleted; + + private System.Threading.SendOrPostCallback AddDigestSubscriberOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveSubscriberOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveDigestSubscriberOperationCompleted; + + private System.Threading.SendOrPostCallback GetSubscriberListOperationCompleted; + + private System.Threading.SendOrPostCallback GetPosterWhiteListOperationCompleted; + + private System.Threading.SendOrPostCallback GetPosterKillListOperationCompleted; + + private System.Threading.SendOrPostCallback GetDigestSubscriberListOperationCompleted; + + private System.Threading.SendOrPostCallback SetSubscriberListOperationCompleted; + + private System.Threading.SendOrPostCallback SetSubscriberList2OperationCompleted; + + private System.Threading.SendOrPostCallback SetDigestSubscriberListOperationCompleted; + + private System.Threading.SendOrPostCallback SetPosterWhiteListOperationCompleted; + + private System.Threading.SendOrPostCallback SetPosterKillListOperationCompleted; + + /// + public svcMailListAdmin() + { + this.Url = "http://127.0.0.1:9998/Services/svcMailListAdmin.asmx"; + } + + /// + public event SetRequestedListSettingsCompletedEventHandler SetRequestedListSettingsCompleted; + + /// + public event GetRequestedListSettingsCompletedEventHandler GetRequestedListSettingsCompleted; + + /// + public event GetMailingListsByDomainCompletedEventHandler GetMailingListsByDomainCompleted; + + /// + public event DeleteAllListsCompletedEventHandler DeleteAllListsCompleted; + + /// + public event DeleteListCompletedEventHandler DeleteListCompleted; + + /// + public event GetListCommandAddressCompletedEventHandler GetListCommandAddressCompleted; + + /// + public event SetListCommandAddressCompletedEventHandler SetListCommandAddressCompleted; + + /// + public event AddListCompletedEventHandler AddListCompleted; + + /// + public event AddSubscriberCompletedEventHandler AddSubscriberCompleted; + + /// + public event AddSubscriber2CompletedEventHandler AddSubscriber2Completed; + + /// + public event AddDigestSubscriberCompletedEventHandler AddDigestSubscriberCompleted; + + /// + public event RemoveSubscriberCompletedEventHandler RemoveSubscriberCompleted; + + /// + public event RemoveDigestSubscriberCompletedEventHandler RemoveDigestSubscriberCompleted; + + /// + public event GetSubscriberListCompletedEventHandler GetSubscriberListCompleted; + + /// + public event GetPosterWhiteListCompletedEventHandler GetPosterWhiteListCompleted; + + /// + public event GetPosterKillListCompletedEventHandler GetPosterKillListCompleted; + + /// + public event GetDigestSubscriberListCompletedEventHandler GetDigestSubscriberListCompleted; + + /// + public event SetSubscriberListCompletedEventHandler SetSubscriberListCompleted; + + /// + public event SetSubscriberList2CompletedEventHandler SetSubscriberList2Completed; + + /// + public event SetDigestSubscriberListCompletedEventHandler SetDigestSubscriberListCompleted; + + /// + public event SetPosterWhiteListCompletedEventHandler SetPosterWhiteListCompleted; + + /// + public event SetPosterKillListCompletedEventHandler SetPosterKillListCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetRequestedListSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetRequestedListSettings(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] newSettings) + { + object[] results = this.Invoke("SetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + newSettings}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetRequestedListSettings(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] newSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + newSettings}, callback, asyncState); + } + + /// + public GenericResult EndSetRequestedListSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetRequestedListSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] newSettings) + { + this.SetRequestedListSettingsAsync(AuthUserName, AuthPassword, DomainName, ListName, newSettings, null); + } + + /// + public void SetRequestedListSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] newSettings, object userState) + { + if ((this.SetRequestedListSettingsOperationCompleted == null)) + { + this.SetRequestedListSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRequestedListSettingsOperationCompleted); + } + this.InvokeAsync("SetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + newSettings}, this.SetRequestedListSettingsOperationCompleted, userState); + } + + private void OnSetRequestedListSettingsOperationCompleted(object arg) + { + if ((this.SetRequestedListSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetRequestedListSettingsCompleted(this, new SetRequestedListSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetRequestedListSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SettingsRequestResult GetRequestedListSettings(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] requestedSettings) + { + object[] results = this.Invoke("GetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + requestedSettings}); + return ((SettingsRequestResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetRequestedListSettings(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] requestedSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + requestedSettings}, callback, asyncState); + } + + /// + public SettingsRequestResult EndGetRequestedListSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SettingsRequestResult)(results[0])); + } + + /// + public void GetRequestedListSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] requestedSettings) + { + this.GetRequestedListSettingsAsync(AuthUserName, AuthPassword, DomainName, ListName, requestedSettings, null); + } + + /// + public void GetRequestedListSettingsAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] requestedSettings, object userState) + { + if ((this.GetRequestedListSettingsOperationCompleted == null)) + { + this.GetRequestedListSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRequestedListSettingsOperationCompleted); + } + this.InvokeAsync("GetRequestedListSettings", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + requestedSettings}, this.GetRequestedListSettingsOperationCompleted, userState); + } + + private void OnGetRequestedListSettingsOperationCompleted(object arg) + { + if ((this.GetRequestedListSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetRequestedListSettingsCompleted(this, new GetRequestedListSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetMailingListsByDomain", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public MailingListResult GetMailingListsByDomain(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetMailingListsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((MailingListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetMailingListsByDomain(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetMailingListsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public MailingListResult EndGetMailingListsByDomain(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((MailingListResult)(results[0])); + } + + /// + public void GetMailingListsByDomainAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetMailingListsByDomainAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetMailingListsByDomainAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetMailingListsByDomainOperationCompleted == null)) + { + this.GetMailingListsByDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetMailingListsByDomainOperationCompleted); + } + this.InvokeAsync("GetMailingListsByDomain", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetMailingListsByDomainOperationCompleted, userState); + } + + private void OnGetMailingListsByDomainOperationCompleted(object arg) + { + if ((this.GetMailingListsByDomainCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetMailingListsByDomainCompleted(this, new GetMailingListsByDomainCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteAllLists", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteAllLists(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("DeleteAllLists", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteAllLists(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteAllLists", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteAllLists(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteAllListsAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.DeleteAllListsAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void DeleteAllListsAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.DeleteAllListsOperationCompleted == null)) + { + this.DeleteAllListsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteAllListsOperationCompleted); + } + this.InvokeAsync("DeleteAllLists", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.DeleteAllListsOperationCompleted, userState); + } + + private void OnDeleteAllListsOperationCompleted(object arg) + { + if ((this.DeleteAllListsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteAllListsCompleted(this, new DeleteAllListsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteList(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + object[] results = this.Invoke("DeleteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteList(string AuthUserName, string AuthPassword, string DomainName, string ListName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + this.DeleteListAsync(AuthUserName, AuthPassword, DomainName, ListName, null); + } + + /// + public void DeleteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, object userState) + { + if ((this.DeleteListOperationCompleted == null)) + { + this.DeleteListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteListOperationCompleted); + } + this.InvokeAsync("DeleteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, this.DeleteListOperationCompleted, userState); + } + + private void OnDeleteListOperationCompleted(object arg) + { + if ((this.DeleteListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteListCompleted(this, new DeleteListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetListCommandAddress", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public ListCommandResult GetListCommandAddress(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((ListCommandResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetListCommandAddress(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public ListCommandResult EndGetListCommandAddress(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((ListCommandResult)(results[0])); + } + + /// + public void GetListCommandAddressAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetListCommandAddressAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetListCommandAddressAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetListCommandAddressOperationCompleted == null)) + { + this.GetListCommandAddressOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetListCommandAddressOperationCompleted); + } + this.InvokeAsync("GetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetListCommandAddressOperationCompleted, userState); + } + + private void OnGetListCommandAddressOperationCompleted(object arg) + { + if ((this.GetListCommandAddressCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetListCommandAddressCompleted(this, new GetListCommandAddressCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetListCommandAddress", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetListCommandAddress(string AuthUserName, string AuthPassword, string DomainName, string commandAddress) + { + object[] results = this.Invoke("SetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName, + commandAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetListCommandAddress(string AuthUserName, string AuthPassword, string DomainName, string commandAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName, + commandAddress}, callback, asyncState); + } + + /// + public GenericResult EndSetListCommandAddress(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetListCommandAddressAsync(string AuthUserName, string AuthPassword, string DomainName, string commandAddress) + { + this.SetListCommandAddressAsync(AuthUserName, AuthPassword, DomainName, commandAddress, null); + } + + /// + public void SetListCommandAddressAsync(string AuthUserName, string AuthPassword, string DomainName, string commandAddress, object userState) + { + if ((this.SetListCommandAddressOperationCompleted == null)) + { + this.SetListCommandAddressOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetListCommandAddressOperationCompleted); + } + this.InvokeAsync("SetListCommandAddress", new object[] { + AuthUserName, + AuthPassword, + DomainName, + commandAddress}, this.SetListCommandAddressOperationCompleted, userState); + } + + private void OnSetListCommandAddressOperationCompleted(object arg) + { + if ((this.SetListCommandAddressCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetListCommandAddressCompleted(this, new SetListCommandAddressCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Moderator, string Description) + { + object[] results = this.Invoke("AddList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Moderator, + Description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Moderator, string Description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Moderator, + Description}, callback, asyncState); + } + + /// + public GenericResult EndAddList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Moderator, string Description) + { + this.AddListAsync(AuthUserName, AuthPassword, DomainName, ListName, Moderator, Description, null); + } + + /// + public void AddListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Moderator, string Description, object userState) + { + if ((this.AddListOperationCompleted == null)) + { + this.AddListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddListOperationCompleted); + } + this.InvokeAsync("AddList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Moderator, + Description}, this.AddListOperationCompleted, userState); + } + + private void OnAddListOperationCompleted(object arg) + { + if ((this.AddListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddListCompleted(this, new AddListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSubscriber", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + object[] results = this.Invoke("AddSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, callback, asyncState); + } + + /// + public GenericResult EndAddSubscriber(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + this.AddSubscriberAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscriber, null); + } + + /// + public void AddSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, object userState) + { + if ((this.AddSubscriberOperationCompleted == null)) + { + this.AddSubscriberOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSubscriberOperationCompleted); + } + this.InvokeAsync("AddSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, this.AddSubscriberOperationCompleted, userState); + } + + private void OnAddSubscriberOperationCompleted(object arg) + { + if ((this.AddSubscriberCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSubscriberCompleted(this, new AddSubscriberCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSubscriber2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSubscriber2(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("AddSubscriber2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSubscriber2(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSubscriber2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndAddSubscriber2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSubscriber2Async(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.AddSubscriber2Async(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void AddSubscriber2Async(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.AddSubscriber2OperationCompleted == null)) + { + this.AddSubscriber2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSubscriber2OperationCompleted); + } + this.InvokeAsync("AddSubscriber2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.AddSubscriber2OperationCompleted, userState); + } + + private void OnAddSubscriber2OperationCompleted(object arg) + { + if ((this.AddSubscriber2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSubscriber2Completed(this, new AddSubscriber2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDigestSubscriber", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDigestSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + object[] results = this.Invoke("AddDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDigestSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, callback, asyncState); + } + + /// + public GenericResult EndAddDigestSubscriber(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDigestSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + this.AddDigestSubscriberAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscriber, null); + } + + /// + public void AddDigestSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, object userState) + { + if ((this.AddDigestSubscriberOperationCompleted == null)) + { + this.AddDigestSubscriberOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDigestSubscriberOperationCompleted); + } + this.InvokeAsync("AddDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, this.AddDigestSubscriberOperationCompleted, userState); + } + + private void OnAddDigestSubscriberOperationCompleted(object arg) + { + if ((this.AddDigestSubscriberCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDigestSubscriberCompleted(this, new AddDigestSubscriberCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveSubscriber", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + object[] results = this.Invoke("RemoveSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, callback, asyncState); + } + + /// + public GenericResult EndRemoveSubscriber(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + this.RemoveSubscriberAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscriber, null); + } + + /// + public void RemoveSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, object userState) + { + if ((this.RemoveSubscriberOperationCompleted == null)) + { + this.RemoveSubscriberOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveSubscriberOperationCompleted); + } + this.InvokeAsync("RemoveSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, this.RemoveSubscriberOperationCompleted, userState); + } + + private void OnRemoveSubscriberOperationCompleted(object arg) + { + if ((this.RemoveSubscriberCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveSubscriberCompleted(this, new RemoveSubscriberCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveDigestSubscriber", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveDigestSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + object[] results = this.Invoke("RemoveDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveDigestSubscriber(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, callback, asyncState); + } + + /// + public GenericResult EndRemoveDigestSubscriber(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveDigestSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber) + { + this.RemoveDigestSubscriberAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscriber, null); + } + + /// + public void RemoveDigestSubscriberAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string Subscriber, object userState) + { + if ((this.RemoveDigestSubscriberOperationCompleted == null)) + { + this.RemoveDigestSubscriberOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveDigestSubscriberOperationCompleted); + } + this.InvokeAsync("RemoveDigestSubscriber", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscriber}, this.RemoveDigestSubscriberOperationCompleted, userState); + } + + private void OnRemoveDigestSubscriberOperationCompleted(object arg) + { + if ((this.RemoveDigestSubscriberCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveDigestSubscriberCompleted(this, new RemoveDigestSubscriberCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetSubscriberList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SubscriberListResult GetSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + object[] results = this.Invoke("GetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}); + return ((SubscriberListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, callback, asyncState); + } + + /// + public SubscriberListResult EndGetSubscriberList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SubscriberListResult)(results[0])); + } + + /// + public void GetSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + this.GetSubscriberListAsync(AuthUserName, AuthPassword, DomainName, ListName, null); + } + + /// + public void GetSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, object userState) + { + if ((this.GetSubscriberListOperationCompleted == null)) + { + this.GetSubscriberListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetSubscriberListOperationCompleted); + } + this.InvokeAsync("GetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, this.GetSubscriberListOperationCompleted, userState); + } + + private void OnGetSubscriberListOperationCompleted(object arg) + { + if ((this.GetSubscriberListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetSubscriberListCompleted(this, new GetSubscriberListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetPosterWhiteList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SubscriberListResult GetPosterWhiteList(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + object[] results = this.Invoke("GetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}); + return ((SubscriberListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetPosterWhiteList(string AuthUserName, string AuthPassword, string DomainName, string ListName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, callback, asyncState); + } + + /// + public SubscriberListResult EndGetPosterWhiteList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SubscriberListResult)(results[0])); + } + + /// + public void GetPosterWhiteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + this.GetPosterWhiteListAsync(AuthUserName, AuthPassword, DomainName, ListName, null); + } + + /// + public void GetPosterWhiteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, object userState) + { + if ((this.GetPosterWhiteListOperationCompleted == null)) + { + this.GetPosterWhiteListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetPosterWhiteListOperationCompleted); + } + this.InvokeAsync("GetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, this.GetPosterWhiteListOperationCompleted, userState); + } + + private void OnGetPosterWhiteListOperationCompleted(object arg) + { + if ((this.GetPosterWhiteListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetPosterWhiteListCompleted(this, new GetPosterWhiteListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetPosterKillList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SubscriberListResult GetPosterKillList(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + object[] results = this.Invoke("GetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}); + return ((SubscriberListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetPosterKillList(string AuthUserName, string AuthPassword, string DomainName, string ListName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, callback, asyncState); + } + + /// + public SubscriberListResult EndGetPosterKillList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SubscriberListResult)(results[0])); + } + + /// + public void GetPosterKillListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + this.GetPosterKillListAsync(AuthUserName, AuthPassword, DomainName, ListName, null); + } + + /// + public void GetPosterKillListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, object userState) + { + if ((this.GetPosterKillListOperationCompleted == null)) + { + this.GetPosterKillListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetPosterKillListOperationCompleted); + } + this.InvokeAsync("GetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, this.GetPosterKillListOperationCompleted, userState); + } + + private void OnGetPosterKillListOperationCompleted(object arg) + { + if ((this.GetPosterKillListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetPosterKillListCompleted(this, new GetPosterKillListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDigestSubscriberList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SubscriberListResult GetDigestSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + object[] results = this.Invoke("GetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}); + return ((SubscriberListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDigestSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, callback, asyncState); + } + + /// + public SubscriberListResult EndGetDigestSubscriberList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SubscriberListResult)(results[0])); + } + + /// + public void GetDigestSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName) + { + this.GetDigestSubscriberListAsync(AuthUserName, AuthPassword, DomainName, ListName, null); + } + + /// + public void GetDigestSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, object userState) + { + if ((this.GetDigestSubscriberListOperationCompleted == null)) + { + this.GetDigestSubscriberListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDigestSubscriberListOperationCompleted); + } + this.InvokeAsync("GetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName}, this.GetDigestSubscriberListOperationCompleted, userState); + } + + private void OnGetDigestSubscriberListOperationCompleted(object arg) + { + if ((this.GetDigestSubscriberListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDigestSubscriberListCompleted(this, new GetDigestSubscriberListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetSubscriberList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("SetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndSetSubscriberList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.SetSubscriberListAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void SetSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.SetSubscriberListOperationCompleted == null)) + { + this.SetSubscriberListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetSubscriberListOperationCompleted); + } + this.InvokeAsync("SetSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.SetSubscriberListOperationCompleted, userState); + } + + private void OnSetSubscriberListOperationCompleted(object arg) + { + if ((this.SetSubscriberListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetSubscriberListCompleted(this, new SetSubscriberListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetSubscriberList2", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetSubscriberList2(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("SetSubscriberList2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetSubscriberList2(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetSubscriberList2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndSetSubscriberList2(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetSubscriberList2Async(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.SetSubscriberList2Async(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void SetSubscriberList2Async(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.SetSubscriberList2OperationCompleted == null)) + { + this.SetSubscriberList2OperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetSubscriberList2OperationCompleted); + } + this.InvokeAsync("SetSubscriberList2", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.SetSubscriberList2OperationCompleted, userState); + } + + private void OnSetSubscriberList2OperationCompleted(object arg) + { + if ((this.SetSubscriberList2Completed != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetSubscriberList2Completed(this, new SetSubscriberList2CompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetDigestSubscriberList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetDigestSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("SetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetDigestSubscriberList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndSetDigestSubscriberList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetDigestSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.SetDigestSubscriberListAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void SetDigestSubscriberListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.SetDigestSubscriberListOperationCompleted == null)) + { + this.SetDigestSubscriberListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDigestSubscriberListOperationCompleted); + } + this.InvokeAsync("SetDigestSubscriberList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.SetDigestSubscriberListOperationCompleted, userState); + } + + private void OnSetDigestSubscriberListOperationCompleted(object arg) + { + if ((this.SetDigestSubscriberListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetDigestSubscriberListCompleted(this, new SetDigestSubscriberListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetPosterWhiteList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetPosterWhiteList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("SetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetPosterWhiteList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndSetPosterWhiteList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetPosterWhiteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.SetPosterWhiteListAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void SetPosterWhiteListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.SetPosterWhiteListOperationCompleted == null)) + { + this.SetPosterWhiteListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetPosterWhiteListOperationCompleted); + } + this.InvokeAsync("SetPosterWhiteList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.SetPosterWhiteListOperationCompleted, userState); + } + + private void OnSetPosterWhiteListOperationCompleted(object arg) + { + if ((this.SetPosterWhiteListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetPosterWhiteListCompleted(this, new SetPosterWhiteListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetPosterKillList", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetPosterKillList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + object[] results = this.Invoke("SetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetPosterKillList(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, callback, asyncState); + } + + /// + public GenericResult EndSetPosterKillList(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetPosterKillListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers) + { + this.SetPosterKillListAsync(AuthUserName, AuthPassword, DomainName, ListName, Subscribers, null); + } + + /// + public void SetPosterKillListAsync(string AuthUserName, string AuthPassword, string DomainName, string ListName, string[] Subscribers, object userState) + { + if ((this.SetPosterKillListOperationCompleted == null)) + { + this.SetPosterKillListOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetPosterKillListOperationCompleted); + } + this.InvokeAsync("SetPosterKillList", new object[] { + AuthUserName, + AuthPassword, + DomainName, + ListName, + Subscribers}, this.SetPosterKillListOperationCompleted, userState); + } + + private void OnSetPosterKillListOperationCompleted(object arg) + { + if ((this.SetPosterKillListCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetPosterKillListCompleted(this, new SetPosterKillListCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SubscriberListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] subscribersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] Subscribers + { + get + { + return this.subscribersField; + } + set + { + this.subscribersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class ListCommandResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string commandAddressField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string commandAddress + { + get + { + return this.commandAddressField; + } + set + { + this.commandAddressField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class MailingListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] listNamesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] listNames + { + get + { + return this.listNamesField; + } + set + { + this.listNamesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetRequestedListSettingsCompletedEventHandler(object sender, SetRequestedListSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetRequestedListSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetRequestedListSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetRequestedListSettingsCompletedEventHandler(object sender, GetRequestedListSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetRequestedListSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetRequestedListSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SettingsRequestResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SettingsRequestResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetMailingListsByDomainCompletedEventHandler(object sender, GetMailingListsByDomainCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetMailingListsByDomainCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetMailingListsByDomainCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public MailingListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((MailingListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteAllListsCompletedEventHandler(object sender, DeleteAllListsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteAllListsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteAllListsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteListCompletedEventHandler(object sender, DeleteListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetListCommandAddressCompletedEventHandler(object sender, GetListCommandAddressCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetListCommandAddressCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetListCommandAddressCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public ListCommandResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((ListCommandResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetListCommandAddressCompletedEventHandler(object sender, SetListCommandAddressCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetListCommandAddressCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetListCommandAddressCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddListCompletedEventHandler(object sender, AddListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSubscriberCompletedEventHandler(object sender, AddSubscriberCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSubscriberCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSubscriberCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSubscriber2CompletedEventHandler(object sender, AddSubscriber2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSubscriber2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSubscriber2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDigestSubscriberCompletedEventHandler(object sender, AddDigestSubscriberCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDigestSubscriberCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDigestSubscriberCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveSubscriberCompletedEventHandler(object sender, RemoveSubscriberCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveSubscriberCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveSubscriberCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveDigestSubscriberCompletedEventHandler(object sender, RemoveDigestSubscriberCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveDigestSubscriberCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveDigestSubscriberCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetSubscriberListCompletedEventHandler(object sender, GetSubscriberListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetSubscriberListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetSubscriberListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SubscriberListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SubscriberListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetPosterWhiteListCompletedEventHandler(object sender, GetPosterWhiteListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetPosterWhiteListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetPosterWhiteListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SubscriberListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SubscriberListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetPosterKillListCompletedEventHandler(object sender, GetPosterKillListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetPosterKillListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetPosterKillListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SubscriberListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SubscriberListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDigestSubscriberListCompletedEventHandler(object sender, GetDigestSubscriberListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDigestSubscriberListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDigestSubscriberListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SubscriberListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SubscriberListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetSubscriberListCompletedEventHandler(object sender, SetSubscriberListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetSubscriberListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetSubscriberListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetSubscriberList2CompletedEventHandler(object sender, SetSubscriberList2CompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetSubscriberList2CompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetSubscriberList2CompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetDigestSubscriberListCompletedEventHandler(object sender, SetDigestSubscriberListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetDigestSubscriberListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetDigestSubscriberListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetPosterWhiteListCompletedEventHandler(object sender, SetPosterWhiteListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetPosterWhiteListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetPosterWhiteListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetPosterKillListCompletedEventHandler(object sender, SetPosterKillListCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetPosterKillListCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetPosterKillListCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcDomainAliasAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcDomainAliasAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback AddDomainAliasWithoutMxCheckOperationCompleted; + + private System.Threading.SendOrPostCallback AddDomainAliasOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteDomainAliasOperationCompleted; + + private System.Threading.SendOrPostCallback GetAliasesOperationCompleted; + + /// + public svcDomainAliasAdmin() + { + this.Url = "http://127.0.0.1:9998/Services/svcDomainAliasAdmin.asmx"; + } + + /// + public event AddDomainAliasWithoutMxCheckCompletedEventHandler AddDomainAliasWithoutMxCheckCompleted; + + /// + public event AddDomainAliasCompletedEventHandler AddDomainAliasCompleted; + + /// + public event DeleteDomainAliasCompletedEventHandler DeleteDomainAliasCompleted; + + /// + public event GetAliasesCompletedEventHandler GetAliasesCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDomainAliasWithoutMxCheck", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDomainAliasWithoutMxCheck(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + object[] results = this.Invoke("AddDomainAliasWithoutMxCheck", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDomainAliasWithoutMxCheck(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDomainAliasWithoutMxCheck", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, callback, asyncState); + } + + /// + public GenericResult EndAddDomainAliasWithoutMxCheck(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDomainAliasWithoutMxCheckAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + this.AddDomainAliasWithoutMxCheckAsync(AuthUserName, AuthPassword, DomainName, DomainAliasName, null); + } + + /// + public void AddDomainAliasWithoutMxCheckAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, object userState) + { + if ((this.AddDomainAliasWithoutMxCheckOperationCompleted == null)) + { + this.AddDomainAliasWithoutMxCheckOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDomainAliasWithoutMxCheckOperationCompleted); + } + this.InvokeAsync("AddDomainAliasWithoutMxCheck", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, this.AddDomainAliasWithoutMxCheckOperationCompleted, userState); + } + + private void OnAddDomainAliasWithoutMxCheckOperationCompleted(object arg) + { + if ((this.AddDomainAliasWithoutMxCheckCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDomainAliasWithoutMxCheckCompleted(this, new AddDomainAliasWithoutMxCheckCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDomainAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDomainAlias(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + object[] results = this.Invoke("AddDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDomainAlias(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, callback, asyncState); + } + + /// + public GenericResult EndAddDomainAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDomainAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + this.AddDomainAliasAsync(AuthUserName, AuthPassword, DomainName, DomainAliasName, null); + } + + /// + public void AddDomainAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, object userState) + { + if ((this.AddDomainAliasOperationCompleted == null)) + { + this.AddDomainAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDomainAliasOperationCompleted); + } + this.InvokeAsync("AddDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, this.AddDomainAliasOperationCompleted, userState); + } + + private void OnAddDomainAliasOperationCompleted(object arg) + { + if ((this.AddDomainAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDomainAliasCompleted(this, new AddDomainAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteDomainAlias", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteDomainAlias(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + object[] results = this.Invoke("DeleteDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteDomainAlias(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteDomainAlias(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteDomainAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName) + { + this.DeleteDomainAliasAsync(AuthUserName, AuthPassword, DomainName, DomainAliasName, null); + } + + /// + public void DeleteDomainAliasAsync(string AuthUserName, string AuthPassword, string DomainName, string DomainAliasName, object userState) + { + if ((this.DeleteDomainAliasOperationCompleted == null)) + { + this.DeleteDomainAliasOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteDomainAliasOperationCompleted); + } + this.InvokeAsync("DeleteDomainAlias", new object[] { + AuthUserName, + AuthPassword, + DomainName, + DomainAliasName}, this.DeleteDomainAliasOperationCompleted, userState); + } + + private void OnDeleteDomainAliasOperationCompleted(object arg) + { + if ((this.DeleteDomainAliasCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteDomainAliasCompleted(this, new DeleteDomainAliasCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetAliases", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DomainAliasInfoListResult GetAliases(string AuthUserName, string AuthPassword, string DomainName) + { + object[] results = this.Invoke("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}); + return ((DomainAliasInfoListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetAliases(string AuthUserName, string AuthPassword, string DomainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}, callback, asyncState); + } + + /// + public DomainAliasInfoListResult EndGetAliases(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DomainAliasInfoListResult)(results[0])); + } + + /// + public void GetAliasesAsync(string AuthUserName, string AuthPassword, string DomainName) + { + this.GetAliasesAsync(AuthUserName, AuthPassword, DomainName, null); + } + + /// + public void GetAliasesAsync(string AuthUserName, string AuthPassword, string DomainName, object userState) + { + if ((this.GetAliasesOperationCompleted == null)) + { + this.GetAliasesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetAliasesOperationCompleted); + } + this.InvokeAsync("GetAliases", new object[] { + AuthUserName, + AuthPassword, + DomainName}, this.GetAliasesOperationCompleted, userState); + } + + private void OnGetAliasesOperationCompleted(object arg) + { + if ((this.GetAliasesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetAliasesCompleted(this, new GetAliasesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DomainAliasInfoListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] domainAliasNamesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] DomainAliasNames + { + get + { + return this.domainAliasNamesField; + } + set + { + this.domainAliasNamesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDomainAliasWithoutMxCheckCompletedEventHandler(object sender, AddDomainAliasWithoutMxCheckCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDomainAliasWithoutMxCheckCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDomainAliasWithoutMxCheckCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDomainAliasCompletedEventHandler(object sender, AddDomainAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDomainAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDomainAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteDomainAliasCompletedEventHandler(object sender, DeleteDomainAliasCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteDomainAliasCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteDomainAliasCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Web.Services.WebServiceBindingAttribute(Name = "svcServerAdminSoap", Namespace = "http://tempuri.org/")] + public partial class svcServerAdmin : System.Web.Services.Protocols.SoapHttpClientProtocol + { + + private System.Threading.SendOrPostCallback StartServicesOperationCompleted; + + private System.Threading.SendOrPostCallback StopServicesOperationCompleted; + + private System.Threading.SendOrPostCallback RequestStatusOperationCompleted; + + private System.Threading.SendOrPostCallback GetEditionOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteServerPortOperationCompleted; + + private System.Threading.SendOrPostCallback ListServerPortsOperationCompleted; + + private System.Threading.SendOrPostCallback AddServerPortOperationCompleted; + + private System.Threading.SendOrPostCallback GetSMTPBlockedSendersOperationCompleted; + + private System.Threading.SendOrPostCallback AddDOSAbuseDetectionRuleOperationCompleted; + + private System.Threading.SendOrPostCallback AddHarvestingAbuseDetectionRuleOperationCompleted; + + private System.Threading.SendOrPostCallback AddIncomingGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback GetIncomingGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback ListIncomingGatewaysOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateIncomingGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveIncomingGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback AddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteAbuseDetectionRuleOperationCompleted; + + private System.Threading.SendOrPostCallback GetDOSAbuseDetectionRulesOperationCompleted; + + private System.Threading.SendOrPostCallback GetHarvestingAbuseDetectionRulesOperationCompleted; + + private System.Threading.SendOrPostCallback GetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted; + + private System.Threading.SendOrPostCallback AddSMTPBlockedSenderOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteSpamAssassinServerOperationCompleted; + + private System.Threading.SendOrPostCallback AddSpamAssassinServerOperationCompleted; + + private System.Threading.SendOrPostCallback ListSpamAssassinServersOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedSystemSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback SetRequestedSystemSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetSpoolMessageCountOperationCompleted; + + private System.Threading.SendOrPostCallback ListGreylistingFiltersOperationCompleted; + + private System.Threading.SendOrPostCallback ListPortsAssignedToIPOperationCompleted; + + private System.Threading.SendOrPostCallback RemovePortFromIPOperationCompleted; + + private System.Threading.SendOrPostCallback AssignPortToIPOperationCompleted; + + private System.Threading.SendOrPostCallback ListGatewaysOperationCompleted; + + private System.Threading.SendOrPostCallback GetGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback GetGlobalTrustedSendersOperationCompleted; + + private System.Threading.SendOrPostCallback AddGlobalTrustedSenderOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteGlobalTrustedSenderOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteGreylistingFilterOperationCompleted; + + private System.Threading.SendOrPostCallback GetWhitelistEntriesOperationCompleted; + + private System.Threading.SendOrPostCallback GetBlacklistEntriesOperationCompleted; + + private System.Threading.SendOrPostCallback SetBlacklistEntryOperationCompleted; + + private System.Threading.SendOrPostCallback SetWhitelistEntryOperationCompleted; + + private System.Threading.SendOrPostCallback AddGreylistingFilterOperationCompleted; + + private System.Threading.SendOrPostCallback AddSmtpAuthenticationBypassOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteSmtpAuthenticationBypassOperationCompleted; + + private System.Threading.SendOrPostCallback GetSmtpAuthenticationBypassesOperationCompleted; + + private System.Threading.SendOrPostCallback AddGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback AddSmarterMailGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback ListSystemAdminsOperationCompleted; + + private System.Threading.SendOrPostCallback SetSystemAdminPasswordOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteSystemAdminOperationCompleted; + + private System.Threading.SendOrPostCallback AddSystemAdminOperationCompleted; + + private System.Threading.SendOrPostCallback AddIPRestrictionToSystemAdminOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveIPRestrictionFromSystemAdminOperationCompleted; + + private System.Threading.SendOrPostCallback AddHostnameOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteHostnameOperationCompleted; + + private System.Threading.SendOrPostCallback ListHostnamesOperationCompleted; + + private System.Threading.SendOrPostCallback AddFolderAutocleanRuleOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteFolderAutoCleanRuleOperationCompleted; + + private System.Threading.SendOrPostCallback ListFolderAutoCleanRulesOperationCompleted; + + private System.Threading.SendOrPostCallback AddForwardingBlacklistEntryOperationCompleted; + + private System.Threading.SendOrPostCallback DeleteForwardingBlacklistEntryOperationCompleted; + + private System.Threading.SendOrPostCallback ListForwardingBlacklistEntriesOperationCompleted; + + /// + public svcServerAdmin() + { + this.Url = "http://127.0.0.1:9998/services/svcServerAdmin.asmx"; + } + + /// + public event StartServicesCompletedEventHandler StartServicesCompleted; + + /// + public event StopServicesCompletedEventHandler StopServicesCompleted; + + /// + public event RequestStatusCompletedEventHandler RequestStatusCompleted; + + /// + public event GetEditionCompletedEventHandler GetEditionCompleted; + + /// + public event DeleteServerPortCompletedEventHandler DeleteServerPortCompleted; + + /// + public event ListServerPortsCompletedEventHandler ListServerPortsCompleted; + + /// + public event AddServerPortCompletedEventHandler AddServerPortCompleted; + + /// + public event GetSMTPBlockedSendersCompletedEventHandler GetSMTPBlockedSendersCompleted; + + /// + public event AddDOSAbuseDetectionRuleCompletedEventHandler AddDOSAbuseDetectionRuleCompleted; + + /// + public event AddHarvestingAbuseDetectionRuleCompletedEventHandler AddHarvestingAbuseDetectionRuleCompleted; + + /// + public event AddIncomingGatewayCompletedEventHandler AddIncomingGatewayCompleted; + + /// + public event GetIncomingGatewayCompletedEventHandler GetIncomingGatewayCompleted; + + /// + public event ListIncomingGatewaysCompletedEventHandler ListIncomingGatewaysCompleted; + + /// + public event UpdateIncomingGatewayCompletedEventHandler UpdateIncomingGatewayCompleted; + + /// + public event RemoveIncomingGatewayCompletedEventHandler RemoveIncomingGatewayCompleted; + + /// + public event AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventHandler AddInternalSpammerNotificationAbuseDetectionRuleCompleted; + + /// + public event DeleteAbuseDetectionRuleCompletedEventHandler DeleteAbuseDetectionRuleCompleted; + + /// + public event GetDOSAbuseDetectionRulesCompletedEventHandler GetDOSAbuseDetectionRulesCompleted; + + /// + public event GetHarvestingAbuseDetectionRulesCompletedEventHandler GetHarvestingAbuseDetectionRulesCompleted; + + /// + public event GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventHandler GetInternalSpammerNotificationAbuseDetectionRulesCompleted; + + /// + public event AddSMTPBlockedSenderCompletedEventHandler AddSMTPBlockedSenderCompleted; + + /// + public event DeleteSpamAssassinServerCompletedEventHandler DeleteSpamAssassinServerCompleted; + + /// + public event AddSpamAssassinServerCompletedEventHandler AddSpamAssassinServerCompleted; + + /// + public event ListSpamAssassinServersCompletedEventHandler ListSpamAssassinServersCompleted; + + /// + public event GetRequestedSystemSettingsCompletedEventHandler GetRequestedSystemSettingsCompleted; + + /// + public event SetRequestedSystemSettingsCompletedEventHandler SetRequestedSystemSettingsCompleted; + + /// + public event GetSpoolMessageCountCompletedEventHandler GetSpoolMessageCountCompleted; + + /// + public event ListGreylistingFiltersCompletedEventHandler ListGreylistingFiltersCompleted; + + /// + public event ListPortsAssignedToIPCompletedEventHandler ListPortsAssignedToIPCompleted; + + /// + public event RemovePortFromIPCompletedEventHandler RemovePortFromIPCompleted; + + /// + public event AssignPortToIPCompletedEventHandler AssignPortToIPCompleted; + + /// + public event ListGatewaysCompletedEventHandler ListGatewaysCompleted; + + /// + public event GetGatewayCompletedEventHandler GetGatewayCompleted; + + /// + public event GetGlobalTrustedSendersCompletedEventHandler GetGlobalTrustedSendersCompleted; + + /// + public event AddGlobalTrustedSenderCompletedEventHandler AddGlobalTrustedSenderCompleted; + + /// + public event DeleteGlobalTrustedSenderCompletedEventHandler DeleteGlobalTrustedSenderCompleted; + + /// + public event DeleteGreylistingFilterCompletedEventHandler DeleteGreylistingFilterCompleted; + + /// + public event GetWhitelistEntriesCompletedEventHandler GetWhitelistEntriesCompleted; + + /// + public event GetBlacklistEntriesCompletedEventHandler GetBlacklistEntriesCompleted; + + /// + public event SetBlacklistEntryCompletedEventHandler SetBlacklistEntryCompleted; + + /// + public event SetWhitelistEntryCompletedEventHandler SetWhitelistEntryCompleted; + + /// + public event AddGreylistingFilterCompletedEventHandler AddGreylistingFilterCompleted; + + /// + public event AddSmtpAuthenticationBypassCompletedEventHandler AddSmtpAuthenticationBypassCompleted; + + /// + public event DeleteSmtpAuthenticationBypassCompletedEventHandler DeleteSmtpAuthenticationBypassCompleted; + + /// + public event GetSmtpAuthenticationBypassesCompletedEventHandler GetSmtpAuthenticationBypassesCompleted; + + /// + public event AddGatewayCompletedEventHandler AddGatewayCompleted; + + /// + public event AddSmarterMailGatewayCompletedEventHandler AddSmarterMailGatewayCompleted; + + /// + public event RemoveGatewayCompletedEventHandler RemoveGatewayCompleted; + + /// + public event UpdateGatewayCompletedEventHandler UpdateGatewayCompleted; + + /// + public event ListSystemAdminsCompletedEventHandler ListSystemAdminsCompleted; + + /// + public event SetSystemAdminPasswordCompletedEventHandler SetSystemAdminPasswordCompleted; + + /// + public event DeleteSystemAdminCompletedEventHandler DeleteSystemAdminCompleted; + + /// + public event AddSystemAdminCompletedEventHandler AddSystemAdminCompleted; + + /// + public event AddIPRestrictionToSystemAdminCompletedEventHandler AddIPRestrictionToSystemAdminCompleted; + + /// + public event RemoveIPRestrictionFromSystemAdminCompletedEventHandler RemoveIPRestrictionFromSystemAdminCompleted; + + /// + public event AddHostnameCompletedEventHandler AddHostnameCompleted; + + /// + public event DeleteHostnameCompletedEventHandler DeleteHostnameCompleted; + + /// + public event ListHostnamesCompletedEventHandler ListHostnamesCompleted; + + /// + public event AddFolderAutocleanRuleCompletedEventHandler AddFolderAutocleanRuleCompleted; + + /// + public event DeleteFolderAutoCleanRuleCompletedEventHandler DeleteFolderAutoCleanRuleCompleted; + + /// + public event ListFolderAutoCleanRulesCompletedEventHandler ListFolderAutoCleanRulesCompleted; + + /// + public event AddForwardingBlacklistEntryCompletedEventHandler AddForwardingBlacklistEntryCompleted; + + /// + public event DeleteForwardingBlacklistEntryCompletedEventHandler DeleteForwardingBlacklistEntryCompleted; + + /// + public event ListForwardingBlacklistEntriesCompletedEventHandler ListForwardingBlacklistEntriesCompleted; + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/StartServices", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult StartServices(string AuthUserName, string AuthPassword, string[] ServicesToStart) + { + object[] results = this.Invoke("StartServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStart}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginStartServices(string AuthUserName, string AuthPassword, string[] ServicesToStart, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("StartServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStart}, callback, asyncState); + } + + /// + public GenericResult EndStartServices(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void StartServicesAsync(string AuthUserName, string AuthPassword, string[] ServicesToStart) + { + this.StartServicesAsync(AuthUserName, AuthPassword, ServicesToStart, null); + } + + /// + public void StartServicesAsync(string AuthUserName, string AuthPassword, string[] ServicesToStart, object userState) + { + if ((this.StartServicesOperationCompleted == null)) + { + this.StartServicesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnStartServicesOperationCompleted); + } + this.InvokeAsync("StartServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStart}, this.StartServicesOperationCompleted, userState); + } + + private void OnStartServicesOperationCompleted(object arg) + { + if ((this.StartServicesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.StartServicesCompleted(this, new StartServicesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/StopServices", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult StopServices(string AuthUserName, string AuthPassword, string[] ServicesToStop) + { + object[] results = this.Invoke("StopServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStop}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginStopServices(string AuthUserName, string AuthPassword, string[] ServicesToStop, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("StopServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStop}, callback, asyncState); + } + + /// + public GenericResult EndStopServices(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void StopServicesAsync(string AuthUserName, string AuthPassword, string[] ServicesToStop) + { + this.StopServicesAsync(AuthUserName, AuthPassword, ServicesToStop, null); + } + + /// + public void StopServicesAsync(string AuthUserName, string AuthPassword, string[] ServicesToStop, object userState) + { + if ((this.StopServicesOperationCompleted == null)) + { + this.StopServicesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnStopServicesOperationCompleted); + } + this.InvokeAsync("StopServices", new object[] { + AuthUserName, + AuthPassword, + ServicesToStop}, this.StopServicesOperationCompleted, userState); + } + + private void OnStopServicesOperationCompleted(object arg) + { + if ((this.StopServicesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.StopServicesCompleted(this, new StopServicesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RequestStatus", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public RequestStatusResult RequestStatus(string AuthUserName, string AuthPassword, string[] reqStats) + { + object[] results = this.Invoke("RequestStatus", new object[] { + AuthUserName, + AuthPassword, + reqStats}); + return ((RequestStatusResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRequestStatus(string AuthUserName, string AuthPassword, string[] reqStats, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RequestStatus", new object[] { + AuthUserName, + AuthPassword, + reqStats}, callback, asyncState); + } + + /// + public RequestStatusResult EndRequestStatus(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((RequestStatusResult)(results[0])); + } + + /// + public void RequestStatusAsync(string AuthUserName, string AuthPassword, string[] reqStats) + { + this.RequestStatusAsync(AuthUserName, AuthPassword, reqStats, null); + } + + /// + public void RequestStatusAsync(string AuthUserName, string AuthPassword, string[] reqStats, object userState) + { + if ((this.RequestStatusOperationCompleted == null)) + { + this.RequestStatusOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRequestStatusOperationCompleted); + } + this.InvokeAsync("RequestStatus", new object[] { + AuthUserName, + AuthPassword, + reqStats}, this.RequestStatusOperationCompleted, userState); + } + + private void OnRequestStatusOperationCompleted(object arg) + { + if ((this.RequestStatusCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RequestStatusCompleted(this, new RequestStatusCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetEdition", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public EditionResult GetEdition(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetEdition", new object[] { + AuthUserName, + AuthPassword}); + return ((EditionResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetEdition(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetEdition", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public EditionResult EndGetEdition(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((EditionResult)(results[0])); + } + + /// + public void GetEditionAsync(string AuthUserName, string AuthPassword) + { + this.GetEditionAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetEditionAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetEditionOperationCompleted == null)) + { + this.GetEditionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetEditionOperationCompleted); + } + this.InvokeAsync("GetEdition", new object[] { + AuthUserName, + AuthPassword}, this.GetEditionOperationCompleted, userState); + } + + private void OnGetEditionOperationCompleted(object arg) + { + if ((this.GetEditionCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetEditionCompleted(this, new GetEditionCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteServerPort", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteServerPort(string authUsername, string authPassword, string portId) + { + object[] results = this.Invoke("DeleteServerPort", new object[] { + authUsername, + authPassword, + portId}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteServerPort(string authUsername, string authPassword, string portId, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteServerPort", new object[] { + authUsername, + authPassword, + portId}, callback, asyncState); + } + + /// + public GenericResult EndDeleteServerPort(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteServerPortAsync(string authUsername, string authPassword, string portId) + { + this.DeleteServerPortAsync(authUsername, authPassword, portId, null); + } + + /// + public void DeleteServerPortAsync(string authUsername, string authPassword, string portId, object userState) + { + if ((this.DeleteServerPortOperationCompleted == null)) + { + this.DeleteServerPortOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteServerPortOperationCompleted); + } + this.InvokeAsync("DeleteServerPort", new object[] { + authUsername, + authPassword, + portId}, this.DeleteServerPortOperationCompleted, userState); + } + + private void OnDeleteServerPortOperationCompleted(object arg) + { + if ((this.DeleteServerPortCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteServerPortCompleted(this, new DeleteServerPortCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListServerPorts", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public ServerPortListResult ListServerPorts(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListServerPorts", new object[] { + authUsername, + authPassword}); + return ((ServerPortListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListServerPorts(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListServerPorts", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public ServerPortListResult EndListServerPorts(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((ServerPortListResult)(results[0])); + } + + /// + public void ListServerPortsAsync(string authUsername, string authPassword) + { + this.ListServerPortsAsync(authUsername, authPassword, null); + } + + /// + public void ListServerPortsAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListServerPortsOperationCompleted == null)) + { + this.ListServerPortsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListServerPortsOperationCompleted); + } + this.InvokeAsync("ListServerPorts", new object[] { + authUsername, + authPassword}, this.ListServerPortsOperationCompleted, userState); + } + + private void OnListServerPortsOperationCompleted(object arg) + { + if ((this.ListServerPortsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListServerPortsCompleted(this, new ListServerPortsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddServerPort", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public AddServerPortResult AddServerPort(string authUsername, string authPassword, string protocol, string certificatePath, string encryption, string name, int port, string description) + { + object[] results = this.Invoke("AddServerPort", new object[] { + authUsername, + authPassword, + protocol, + certificatePath, + encryption, + name, + port, + description}); + return ((AddServerPortResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddServerPort(string authUsername, string authPassword, string protocol, string certificatePath, string encryption, string name, int port, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddServerPort", new object[] { + authUsername, + authPassword, + protocol, + certificatePath, + encryption, + name, + port, + description}, callback, asyncState); + } + + /// + public AddServerPortResult EndAddServerPort(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((AddServerPortResult)(results[0])); + } + + /// + public void AddServerPortAsync(string authUsername, string authPassword, string protocol, string certificatePath, string encryption, string name, int port, string description) + { + this.AddServerPortAsync(authUsername, authPassword, protocol, certificatePath, encryption, name, port, description, null); + } + + /// + public void AddServerPortAsync(string authUsername, string authPassword, string protocol, string certificatePath, string encryption, string name, int port, string description, object userState) + { + if ((this.AddServerPortOperationCompleted == null)) + { + this.AddServerPortOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddServerPortOperationCompleted); + } + this.InvokeAsync("AddServerPort", new object[] { + authUsername, + authPassword, + protocol, + certificatePath, + encryption, + name, + port, + description}, this.AddServerPortOperationCompleted, userState); + } + + private void OnAddServerPortOperationCompleted(object arg) + { + if ((this.AddServerPortCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddServerPortCompleted(this, new AddServerPortCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetSMTPBlockedSenders", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SMTPBlockedSenderListResult GetSMTPBlockedSenders(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetSMTPBlockedSenders", new object[] { + authUsername, + authPassword}); + return ((SMTPBlockedSenderListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetSMTPBlockedSenders(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetSMTPBlockedSenders", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public SMTPBlockedSenderListResult EndGetSMTPBlockedSenders(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SMTPBlockedSenderListResult)(results[0])); + } + + /// + public void GetSMTPBlockedSendersAsync(string authUsername, string authPassword) + { + this.GetSMTPBlockedSendersAsync(authUsername, authPassword, null); + } + + /// + public void GetSMTPBlockedSendersAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetSMTPBlockedSendersOperationCompleted == null)) + { + this.GetSMTPBlockedSendersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetSMTPBlockedSendersOperationCompleted); + } + this.InvokeAsync("GetSMTPBlockedSenders", new object[] { + authUsername, + authPassword}, this.GetSMTPBlockedSendersOperationCompleted, userState); + } + + private void OnGetSMTPBlockedSendersOperationCompleted(object arg) + { + if ((this.GetSMTPBlockedSendersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetSMTPBlockedSendersCompleted(this, new GetSMTPBlockedSendersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddDOSAbuseDetectionRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddDOSAbuseDetectionRule(string authUsername, string authPassword, string service, int timeframe, int connectionsBeforeBlock, int timeToBlock, string description) + { + object[] results = this.Invoke("AddDOSAbuseDetectionRule", new object[] { + authUsername, + authPassword, + service, + timeframe, + connectionsBeforeBlock, + timeToBlock, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddDOSAbuseDetectionRule(string authUsername, string authPassword, string service, int timeframe, int connectionsBeforeBlock, int timeToBlock, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddDOSAbuseDetectionRule", new object[] { + authUsername, + authPassword, + service, + timeframe, + connectionsBeforeBlock, + timeToBlock, + description}, callback, asyncState); + } + + /// + public GenericResult EndAddDOSAbuseDetectionRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddDOSAbuseDetectionRuleAsync(string authUsername, string authPassword, string service, int timeframe, int connectionsBeforeBlock, int timeToBlock, string description) + { + this.AddDOSAbuseDetectionRuleAsync(authUsername, authPassword, service, timeframe, connectionsBeforeBlock, timeToBlock, description, null); + } + + /// + public void AddDOSAbuseDetectionRuleAsync(string authUsername, string authPassword, string service, int timeframe, int connectionsBeforeBlock, int timeToBlock, string description, object userState) + { + if ((this.AddDOSAbuseDetectionRuleOperationCompleted == null)) + { + this.AddDOSAbuseDetectionRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddDOSAbuseDetectionRuleOperationCompleted); + } + this.InvokeAsync("AddDOSAbuseDetectionRule", new object[] { + authUsername, + authPassword, + service, + timeframe, + connectionsBeforeBlock, + timeToBlock, + description}, this.AddDOSAbuseDetectionRuleOperationCompleted, userState); + } + + private void OnAddDOSAbuseDetectionRuleOperationCompleted(object arg) + { + if ((this.AddDOSAbuseDetectionRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddDOSAbuseDetectionRuleCompleted(this, new AddDOSAbuseDetectionRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddHarvestingAbuseDetectionRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddHarvestingAbuseDetectionRule(string authUsername, string authPassword, int timeframe, int badSessionsBeforeBlock, int timeToBlock, string description) + { + object[] results = this.Invoke("AddHarvestingAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + badSessionsBeforeBlock, + timeToBlock, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddHarvestingAbuseDetectionRule(string authUsername, string authPassword, int timeframe, int badSessionsBeforeBlock, int timeToBlock, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddHarvestingAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + badSessionsBeforeBlock, + timeToBlock, + description}, callback, asyncState); + } + + /// + public GenericResult EndAddHarvestingAbuseDetectionRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddHarvestingAbuseDetectionRuleAsync(string authUsername, string authPassword, int timeframe, int badSessionsBeforeBlock, int timeToBlock, string description) + { + this.AddHarvestingAbuseDetectionRuleAsync(authUsername, authPassword, timeframe, badSessionsBeforeBlock, timeToBlock, description, null); + } + + /// + public void AddHarvestingAbuseDetectionRuleAsync(string authUsername, string authPassword, int timeframe, int badSessionsBeforeBlock, int timeToBlock, string description, object userState) + { + if ((this.AddHarvestingAbuseDetectionRuleOperationCompleted == null)) + { + this.AddHarvestingAbuseDetectionRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddHarvestingAbuseDetectionRuleOperationCompleted); + } + this.InvokeAsync("AddHarvestingAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + badSessionsBeforeBlock, + timeToBlock, + description}, this.AddHarvestingAbuseDetectionRuleOperationCompleted, userState); + } + + private void OnAddHarvestingAbuseDetectionRuleOperationCompleted(object arg) + { + if ((this.AddHarvestingAbuseDetectionRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddHarvestingAbuseDetectionRuleCompleted(this, new AddHarvestingAbuseDetectionRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddIncomingGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddIncomingGateway(string AuthUserName, string AuthPassword, IncomingGatewayAttributes newIncomingGateway) + { + object[] results = this.Invoke("AddIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + newIncomingGateway}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddIncomingGateway(string AuthUserName, string AuthPassword, IncomingGatewayAttributes newIncomingGateway, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + newIncomingGateway}, callback, asyncState); + } + + /// + public GenericResult EndAddIncomingGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddIncomingGatewayAsync(string AuthUserName, string AuthPassword, IncomingGatewayAttributes newIncomingGateway) + { + this.AddIncomingGatewayAsync(AuthUserName, AuthPassword, newIncomingGateway, null); + } + + /// + public void AddIncomingGatewayAsync(string AuthUserName, string AuthPassword, IncomingGatewayAttributes newIncomingGateway, object userState) + { + if ((this.AddIncomingGatewayOperationCompleted == null)) + { + this.AddIncomingGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddIncomingGatewayOperationCompleted); + } + this.InvokeAsync("AddIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + newIncomingGateway}, this.AddIncomingGatewayOperationCompleted, userState); + } + + private void OnAddIncomingGatewayOperationCompleted(object arg) + { + if ((this.AddIncomingGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddIncomingGatewayCompleted(this, new AddIncomingGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetIncomingGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public IncomingGatewayResult GetIncomingGateway(string AuthUserName, string AuthPassword, string guid) + { + object[] results = this.Invoke("GetIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}); + return ((IncomingGatewayResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetIncomingGateway(string AuthUserName, string AuthPassword, string guid, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, callback, asyncState); + } + + /// + public IncomingGatewayResult EndGetIncomingGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((IncomingGatewayResult)(results[0])); + } + + /// + public void GetIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid) + { + this.GetIncomingGatewayAsync(AuthUserName, AuthPassword, guid, null); + } + + /// + public void GetIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid, object userState) + { + if ((this.GetIncomingGatewayOperationCompleted == null)) + { + this.GetIncomingGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetIncomingGatewayOperationCompleted); + } + this.InvokeAsync("GetIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, this.GetIncomingGatewayOperationCompleted, userState); + } + + private void OnGetIncomingGatewayOperationCompleted(object arg) + { + if ((this.GetIncomingGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetIncomingGatewayCompleted(this, new GetIncomingGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListIncomingGateways", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public IncomingGatewayListResult ListIncomingGateways(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("ListIncomingGateways", new object[] { + AuthUserName, + AuthPassword}); + return ((IncomingGatewayListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListIncomingGateways(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListIncomingGateways", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public IncomingGatewayListResult EndListIncomingGateways(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((IncomingGatewayListResult)(results[0])); + } + + /// + public void ListIncomingGatewaysAsync(string AuthUserName, string AuthPassword) + { + this.ListIncomingGatewaysAsync(AuthUserName, AuthPassword, null); + } + + /// + public void ListIncomingGatewaysAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.ListIncomingGatewaysOperationCompleted == null)) + { + this.ListIncomingGatewaysOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListIncomingGatewaysOperationCompleted); + } + this.InvokeAsync("ListIncomingGateways", new object[] { + AuthUserName, + AuthPassword}, this.ListIncomingGatewaysOperationCompleted, userState); + } + + private void OnListIncomingGatewaysOperationCompleted(object arg) + { + if ((this.ListIncomingGatewaysCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListIncomingGatewaysCompleted(this, new ListIncomingGatewaysCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateIncomingGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateIncomingGateway(string AuthUserName, string AuthPassword, string guid, IncomingGatewayAttributes updatedIncomingGateway) + { + object[] results = this.Invoke("UpdateIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + updatedIncomingGateway}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateIncomingGateway(string AuthUserName, string AuthPassword, string guid, IncomingGatewayAttributes updatedIncomingGateway, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + updatedIncomingGateway}, callback, asyncState); + } + + /// + public GenericResult EndUpdateIncomingGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid, IncomingGatewayAttributes updatedIncomingGateway) + { + this.UpdateIncomingGatewayAsync(AuthUserName, AuthPassword, guid, updatedIncomingGateway, null); + } + + /// + public void UpdateIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid, IncomingGatewayAttributes updatedIncomingGateway, object userState) + { + if ((this.UpdateIncomingGatewayOperationCompleted == null)) + { + this.UpdateIncomingGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateIncomingGatewayOperationCompleted); + } + this.InvokeAsync("UpdateIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + updatedIncomingGateway}, this.UpdateIncomingGatewayOperationCompleted, userState); + } + + private void OnUpdateIncomingGatewayOperationCompleted(object arg) + { + if ((this.UpdateIncomingGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateIncomingGatewayCompleted(this, new UpdateIncomingGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveIncomingGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveIncomingGateway(string AuthUserName, string AuthPassword, string guid) + { + object[] results = this.Invoke("RemoveIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveIncomingGateway(string AuthUserName, string AuthPassword, string guid, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, callback, asyncState); + } + + /// + public GenericResult EndRemoveIncomingGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid) + { + this.RemoveIncomingGatewayAsync(AuthUserName, AuthPassword, guid, null); + } + + /// + public void RemoveIncomingGatewayAsync(string AuthUserName, string AuthPassword, string guid, object userState) + { + if ((this.RemoveIncomingGatewayOperationCompleted == null)) + { + this.RemoveIncomingGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveIncomingGatewayOperationCompleted); + } + this.InvokeAsync("RemoveIncomingGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, this.RemoveIncomingGatewayOperationCompleted, userState); + } + + private void OnRemoveIncomingGatewayOperationCompleted(object arg) + { + if ((this.RemoveIncomingGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveIncomingGatewayCompleted(this, new RemoveIncomingGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddInternalSpammerNotificationAbuseDetectionRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddInternalSpammerNotificationAbuseDetectionRule(string authUsername, string authPassword, int timeframe, int messagesBeforeNotify, string emailAddressToNotify, string description) + { + object[] results = this.Invoke("AddInternalSpammerNotificationAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + messagesBeforeNotify, + emailAddressToNotify, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddInternalSpammerNotificationAbuseDetectionRule(string authUsername, string authPassword, int timeframe, int messagesBeforeNotify, string emailAddressToNotify, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddInternalSpammerNotificationAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + messagesBeforeNotify, + emailAddressToNotify, + description}, callback, asyncState); + } + + /// + public GenericResult EndAddInternalSpammerNotificationAbuseDetectionRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddInternalSpammerNotificationAbuseDetectionRuleAsync(string authUsername, string authPassword, int timeframe, int messagesBeforeNotify, string emailAddressToNotify, string description) + { + this.AddInternalSpammerNotificationAbuseDetectionRuleAsync(authUsername, authPassword, timeframe, messagesBeforeNotify, emailAddressToNotify, description, null); + } + + /// + public void AddInternalSpammerNotificationAbuseDetectionRuleAsync(string authUsername, string authPassword, int timeframe, int messagesBeforeNotify, string emailAddressToNotify, string description, object userState) + { + if ((this.AddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted == null)) + { + this.AddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted); + } + this.InvokeAsync("AddInternalSpammerNotificationAbuseDetectionRule", new object[] { + authUsername, + authPassword, + timeframe, + messagesBeforeNotify, + emailAddressToNotify, + description}, this.AddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted, userState); + } + + private void OnAddInternalSpammerNotificationAbuseDetectionRuleOperationCompleted(object arg) + { + if ((this.AddInternalSpammerNotificationAbuseDetectionRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddInternalSpammerNotificationAbuseDetectionRuleCompleted(this, new AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteAbuseDetectionRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteAbuseDetectionRule(string authUsername, string authPassword, string id) + { + object[] results = this.Invoke("DeleteAbuseDetectionRule", new object[] { + authUsername, + authPassword, + id}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteAbuseDetectionRule(string authUsername, string authPassword, string id, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteAbuseDetectionRule", new object[] { + authUsername, + authPassword, + id}, callback, asyncState); + } + + /// + public GenericResult EndDeleteAbuseDetectionRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteAbuseDetectionRuleAsync(string authUsername, string authPassword, string id) + { + this.DeleteAbuseDetectionRuleAsync(authUsername, authPassword, id, null); + } + + /// + public void DeleteAbuseDetectionRuleAsync(string authUsername, string authPassword, string id, object userState) + { + if ((this.DeleteAbuseDetectionRuleOperationCompleted == null)) + { + this.DeleteAbuseDetectionRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteAbuseDetectionRuleOperationCompleted); + } + this.InvokeAsync("DeleteAbuseDetectionRule", new object[] { + authUsername, + authPassword, + id}, this.DeleteAbuseDetectionRuleOperationCompleted, userState); + } + + private void OnDeleteAbuseDetectionRuleOperationCompleted(object arg) + { + if ((this.DeleteAbuseDetectionRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteAbuseDetectionRuleCompleted(this, new DeleteAbuseDetectionRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetDOSAbuseDetectionRules", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public DOSAbuseDetectionRulesListResult GetDOSAbuseDetectionRules(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetDOSAbuseDetectionRules", new object[] { + authUsername, + authPassword}); + return ((DOSAbuseDetectionRulesListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetDOSAbuseDetectionRules(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetDOSAbuseDetectionRules", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public DOSAbuseDetectionRulesListResult EndGetDOSAbuseDetectionRules(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((DOSAbuseDetectionRulesListResult)(results[0])); + } + + /// + public void GetDOSAbuseDetectionRulesAsync(string authUsername, string authPassword) + { + this.GetDOSAbuseDetectionRulesAsync(authUsername, authPassword, null); + } + + /// + public void GetDOSAbuseDetectionRulesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetDOSAbuseDetectionRulesOperationCompleted == null)) + { + this.GetDOSAbuseDetectionRulesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetDOSAbuseDetectionRulesOperationCompleted); + } + this.InvokeAsync("GetDOSAbuseDetectionRules", new object[] { + authUsername, + authPassword}, this.GetDOSAbuseDetectionRulesOperationCompleted, userState); + } + + private void OnGetDOSAbuseDetectionRulesOperationCompleted(object arg) + { + if ((this.GetDOSAbuseDetectionRulesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetDOSAbuseDetectionRulesCompleted(this, new GetDOSAbuseDetectionRulesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetHarvestingAbuseDetectionRules", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public HarvestingAbuseDetectionRulesListResult GetHarvestingAbuseDetectionRules(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetHarvestingAbuseDetectionRules", new object[] { + authUsername, + authPassword}); + return ((HarvestingAbuseDetectionRulesListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetHarvestingAbuseDetectionRules(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetHarvestingAbuseDetectionRules", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public HarvestingAbuseDetectionRulesListResult EndGetHarvestingAbuseDetectionRules(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((HarvestingAbuseDetectionRulesListResult)(results[0])); + } + + /// + public void GetHarvestingAbuseDetectionRulesAsync(string authUsername, string authPassword) + { + this.GetHarvestingAbuseDetectionRulesAsync(authUsername, authPassword, null); + } + + /// + public void GetHarvestingAbuseDetectionRulesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetHarvestingAbuseDetectionRulesOperationCompleted == null)) + { + this.GetHarvestingAbuseDetectionRulesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetHarvestingAbuseDetectionRulesOperationCompleted); + } + this.InvokeAsync("GetHarvestingAbuseDetectionRules", new object[] { + authUsername, + authPassword}, this.GetHarvestingAbuseDetectionRulesOperationCompleted, userState); + } + + private void OnGetHarvestingAbuseDetectionRulesOperationCompleted(object arg) + { + if ((this.GetHarvestingAbuseDetectionRulesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetHarvestingAbuseDetectionRulesCompleted(this, new GetHarvestingAbuseDetectionRulesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetInternalSpammerNotificationAbuseDetectionRules", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public InternalSpammerNotificationAbuseDetectionRulesListResult GetInternalSpammerNotificationAbuseDetectionRules(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetInternalSpammerNotificationAbuseDetectionRules", new object[] { + authUsername, + authPassword}); + return ((InternalSpammerNotificationAbuseDetectionRulesListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetInternalSpammerNotificationAbuseDetectionRules(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetInternalSpammerNotificationAbuseDetectionRules", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public InternalSpammerNotificationAbuseDetectionRulesListResult EndGetInternalSpammerNotificationAbuseDetectionRules(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((InternalSpammerNotificationAbuseDetectionRulesListResult)(results[0])); + } + + /// + public void GetInternalSpammerNotificationAbuseDetectionRulesAsync(string authUsername, string authPassword) + { + this.GetInternalSpammerNotificationAbuseDetectionRulesAsync(authUsername, authPassword, null); + } + + /// + public void GetInternalSpammerNotificationAbuseDetectionRulesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted == null)) + { + this.GetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted); + } + this.InvokeAsync("GetInternalSpammerNotificationAbuseDetectionRules", new object[] { + authUsername, + authPassword}, this.GetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted, userState); + } + + private void OnGetInternalSpammerNotificationAbuseDetectionRulesOperationCompleted(object arg) + { + if ((this.GetInternalSpammerNotificationAbuseDetectionRulesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetInternalSpammerNotificationAbuseDetectionRulesCompleted(this, new GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSMTPBlockedSender", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSMTPBlockedSender(string authUsername, string authPassword, string blockedSender, string description) + { + object[] results = this.Invoke("AddSMTPBlockedSender", new object[] { + authUsername, + authPassword, + blockedSender, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSMTPBlockedSender(string authUsername, string authPassword, string blockedSender, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSMTPBlockedSender", new object[] { + authUsername, + authPassword, + blockedSender, + description}, callback, asyncState); + } + + /// + public GenericResult EndAddSMTPBlockedSender(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSMTPBlockedSenderAsync(string authUsername, string authPassword, string blockedSender, string description) + { + this.AddSMTPBlockedSenderAsync(authUsername, authPassword, blockedSender, description, null); + } + + /// + public void AddSMTPBlockedSenderAsync(string authUsername, string authPassword, string blockedSender, string description, object userState) + { + if ((this.AddSMTPBlockedSenderOperationCompleted == null)) + { + this.AddSMTPBlockedSenderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSMTPBlockedSenderOperationCompleted); + } + this.InvokeAsync("AddSMTPBlockedSender", new object[] { + authUsername, + authPassword, + blockedSender, + description}, this.AddSMTPBlockedSenderOperationCompleted, userState); + } + + private void OnAddSMTPBlockedSenderOperationCompleted(object arg) + { + if ((this.AddSMTPBlockedSenderCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSMTPBlockedSenderCompleted(this, new AddSMTPBlockedSenderCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteSpamAssassinServer", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteSpamAssassinServer(string authUsername, string authPassword, string serverName) + { + object[] results = this.Invoke("DeleteSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteSpamAssassinServer(string authUsername, string authPassword, string serverName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteSpamAssassinServer(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteSpamAssassinServerAsync(string authUsername, string authPassword, string serverName) + { + this.DeleteSpamAssassinServerAsync(authUsername, authPassword, serverName, null); + } + + /// + public void DeleteSpamAssassinServerAsync(string authUsername, string authPassword, string serverName, object userState) + { + if ((this.DeleteSpamAssassinServerOperationCompleted == null)) + { + this.DeleteSpamAssassinServerOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteSpamAssassinServerOperationCompleted); + } + this.InvokeAsync("DeleteSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName}, this.DeleteSpamAssassinServerOperationCompleted, userState); + } + + private void OnDeleteSpamAssassinServerOperationCompleted(object arg) + { + if ((this.DeleteSpamAssassinServerCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteSpamAssassinServerCompleted(this, new DeleteSpamAssassinServerCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSpamAssassinServer", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSpamAssassinServer(string authUsername, string authPassword, string serverName, string ipAddress, int serverPort) + { + object[] results = this.Invoke("AddSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName, + ipAddress, + serverPort}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSpamAssassinServer(string authUsername, string authPassword, string serverName, string ipAddress, int serverPort, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName, + ipAddress, + serverPort}, callback, asyncState); + } + + /// + public GenericResult EndAddSpamAssassinServer(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSpamAssassinServerAsync(string authUsername, string authPassword, string serverName, string ipAddress, int serverPort) + { + this.AddSpamAssassinServerAsync(authUsername, authPassword, serverName, ipAddress, serverPort, null); + } + + /// + public void AddSpamAssassinServerAsync(string authUsername, string authPassword, string serverName, string ipAddress, int serverPort, object userState) + { + if ((this.AddSpamAssassinServerOperationCompleted == null)) + { + this.AddSpamAssassinServerOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSpamAssassinServerOperationCompleted); + } + this.InvokeAsync("AddSpamAssassinServer", new object[] { + authUsername, + authPassword, + serverName, + ipAddress, + serverPort}, this.AddSpamAssassinServerOperationCompleted, userState); + } + + private void OnAddSpamAssassinServerOperationCompleted(object arg) + { + if ((this.AddSpamAssassinServerCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSpamAssassinServerCompleted(this, new AddSpamAssassinServerCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListSpamAssassinServers", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SpamAssassinServerListResult ListSpamAssassinServers(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListSpamAssassinServers", new object[] { + authUsername, + authPassword}); + return ((SpamAssassinServerListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListSpamAssassinServers(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListSpamAssassinServers", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public SpamAssassinServerListResult EndListSpamAssassinServers(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SpamAssassinServerListResult)(results[0])); + } + + /// + public void ListSpamAssassinServersAsync(string authUsername, string authPassword) + { + this.ListSpamAssassinServersAsync(authUsername, authPassword, null); + } + + /// + public void ListSpamAssassinServersAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListSpamAssassinServersOperationCompleted == null)) + { + this.ListSpamAssassinServersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListSpamAssassinServersOperationCompleted); + } + this.InvokeAsync("ListSpamAssassinServers", new object[] { + authUsername, + authPassword}, this.ListSpamAssassinServersOperationCompleted, userState); + } + + private void OnListSpamAssassinServersOperationCompleted(object arg) + { + if ((this.ListSpamAssassinServersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListSpamAssassinServersCompleted(this, new ListSpamAssassinServersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetRequestedSystemSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public RequestSettingsResult GetRequestedSystemSettings(string AuthUserName, string AuthPassword, string[] reqSettings) + { + object[] results = this.Invoke("GetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + reqSettings}); + return ((RequestSettingsResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetRequestedSystemSettings(string AuthUserName, string AuthPassword, string[] reqSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + reqSettings}, callback, asyncState); + } + + /// + public RequestSettingsResult EndGetRequestedSystemSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((RequestSettingsResult)(results[0])); + } + + /// + public void GetRequestedSystemSettingsAsync(string AuthUserName, string AuthPassword, string[] reqSettings) + { + this.GetRequestedSystemSettingsAsync(AuthUserName, AuthPassword, reqSettings, null); + } + + /// + public void GetRequestedSystemSettingsAsync(string AuthUserName, string AuthPassword, string[] reqSettings, object userState) + { + if ((this.GetRequestedSystemSettingsOperationCompleted == null)) + { + this.GetRequestedSystemSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetRequestedSystemSettingsOperationCompleted); + } + this.InvokeAsync("GetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + reqSettings}, this.GetRequestedSystemSettingsOperationCompleted, userState); + } + + private void OnGetRequestedSystemSettingsOperationCompleted(object arg) + { + if ((this.GetRequestedSystemSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetRequestedSystemSettingsCompleted(this, new GetRequestedSystemSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetRequestedSystemSettings", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetRequestedSystemSettings(string AuthUserName, string AuthPassword, string[] newSettings) + { + object[] results = this.Invoke("SetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + newSettings}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetRequestedSystemSettings(string AuthUserName, string AuthPassword, string[] newSettings, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + newSettings}, callback, asyncState); + } + + /// + public GenericResult EndSetRequestedSystemSettings(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetRequestedSystemSettingsAsync(string AuthUserName, string AuthPassword, string[] newSettings) + { + this.SetRequestedSystemSettingsAsync(AuthUserName, AuthPassword, newSettings, null); + } + + /// + public void SetRequestedSystemSettingsAsync(string AuthUserName, string AuthPassword, string[] newSettings, object userState) + { + if ((this.SetRequestedSystemSettingsOperationCompleted == null)) + { + this.SetRequestedSystemSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetRequestedSystemSettingsOperationCompleted); + } + this.InvokeAsync("SetRequestedSystemSettings", new object[] { + AuthUserName, + AuthPassword, + newSettings}, this.SetRequestedSystemSettingsOperationCompleted, userState); + } + + private void OnSetRequestedSystemSettingsOperationCompleted(object arg) + { + if ((this.SetRequestedSystemSettingsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetRequestedSystemSettingsCompleted(this, new SetRequestedSystemSettingsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetSpoolMessageCount", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public MessageCountResult GetSpoolMessageCount(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("GetSpoolMessageCount", new object[] { + AuthUserName, + AuthPassword}); + return ((MessageCountResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetSpoolMessageCount(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetSpoolMessageCount", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public MessageCountResult EndGetSpoolMessageCount(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((MessageCountResult)(results[0])); + } + + /// + public void GetSpoolMessageCountAsync(string AuthUserName, string AuthPassword) + { + this.GetSpoolMessageCountAsync(AuthUserName, AuthPassword, null); + } + + /// + public void GetSpoolMessageCountAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.GetSpoolMessageCountOperationCompleted == null)) + { + this.GetSpoolMessageCountOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetSpoolMessageCountOperationCompleted); + } + this.InvokeAsync("GetSpoolMessageCount", new object[] { + AuthUserName, + AuthPassword}, this.GetSpoolMessageCountOperationCompleted, userState); + } + + private void OnGetSpoolMessageCountOperationCompleted(object arg) + { + if ((this.GetSpoolMessageCountCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetSpoolMessageCountCompleted(this, new GetSpoolMessageCountCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListGreylistingFilters", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GreylistingFilterListResult ListGreylistingFilters(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListGreylistingFilters", new object[] { + authUsername, + authPassword}); + return ((GreylistingFilterListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListGreylistingFilters(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListGreylistingFilters", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public GreylistingFilterListResult EndListGreylistingFilters(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GreylistingFilterListResult)(results[0])); + } + + /// + public void ListGreylistingFiltersAsync(string authUsername, string authPassword) + { + this.ListGreylistingFiltersAsync(authUsername, authPassword, null); + } + + /// + public void ListGreylistingFiltersAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListGreylistingFiltersOperationCompleted == null)) + { + this.ListGreylistingFiltersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListGreylistingFiltersOperationCompleted); + } + this.InvokeAsync("ListGreylistingFilters", new object[] { + authUsername, + authPassword}, this.ListGreylistingFiltersOperationCompleted, userState); + } + + private void OnListGreylistingFiltersOperationCompleted(object arg) + { + if ((this.ListGreylistingFiltersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListGreylistingFiltersCompleted(this, new ListGreylistingFiltersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListPortsAssignedToIP", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public ServerPortListResult ListPortsAssignedToIP(string authUsername, string authPassword, string ipAddress) + { + object[] results = this.Invoke("ListPortsAssignedToIP", new object[] { + authUsername, + authPassword, + ipAddress}); + return ((ServerPortListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListPortsAssignedToIP(string authUsername, string authPassword, string ipAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListPortsAssignedToIP", new object[] { + authUsername, + authPassword, + ipAddress}, callback, asyncState); + } + + /// + public ServerPortListResult EndListPortsAssignedToIP(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((ServerPortListResult)(results[0])); + } + + /// + public void ListPortsAssignedToIPAsync(string authUsername, string authPassword, string ipAddress) + { + this.ListPortsAssignedToIPAsync(authUsername, authPassword, ipAddress, null); + } + + /// + public void ListPortsAssignedToIPAsync(string authUsername, string authPassword, string ipAddress, object userState) + { + if ((this.ListPortsAssignedToIPOperationCompleted == null)) + { + this.ListPortsAssignedToIPOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListPortsAssignedToIPOperationCompleted); + } + this.InvokeAsync("ListPortsAssignedToIP", new object[] { + authUsername, + authPassword, + ipAddress}, this.ListPortsAssignedToIPOperationCompleted, userState); + } + + private void OnListPortsAssignedToIPOperationCompleted(object arg) + { + if ((this.ListPortsAssignedToIPCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListPortsAssignedToIPCompleted(this, new ListPortsAssignedToIPCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemovePortFromIP", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemovePortFromIP(string authUsername, string authPassword, string portID, string ipAddress) + { + object[] results = this.Invoke("RemovePortFromIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemovePortFromIP(string authUsername, string authPassword, string portID, string ipAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemovePortFromIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}, callback, asyncState); + } + + /// + public GenericResult EndRemovePortFromIP(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemovePortFromIPAsync(string authUsername, string authPassword, string portID, string ipAddress) + { + this.RemovePortFromIPAsync(authUsername, authPassword, portID, ipAddress, null); + } + + /// + public void RemovePortFromIPAsync(string authUsername, string authPassword, string portID, string ipAddress, object userState) + { + if ((this.RemovePortFromIPOperationCompleted == null)) + { + this.RemovePortFromIPOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemovePortFromIPOperationCompleted); + } + this.InvokeAsync("RemovePortFromIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}, this.RemovePortFromIPOperationCompleted, userState); + } + + private void OnRemovePortFromIPOperationCompleted(object arg) + { + if ((this.RemovePortFromIPCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemovePortFromIPCompleted(this, new RemovePortFromIPCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AssignPortToIP", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AssignPortToIP(string authUsername, string authPassword, string portID, string ipAddress) + { + object[] results = this.Invoke("AssignPortToIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAssignPortToIP(string authUsername, string authPassword, string portID, string ipAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AssignPortToIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}, callback, asyncState); + } + + /// + public GenericResult EndAssignPortToIP(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AssignPortToIPAsync(string authUsername, string authPassword, string portID, string ipAddress) + { + this.AssignPortToIPAsync(authUsername, authPassword, portID, ipAddress, null); + } + + /// + public void AssignPortToIPAsync(string authUsername, string authPassword, string portID, string ipAddress, object userState) + { + if ((this.AssignPortToIPOperationCompleted == null)) + { + this.AssignPortToIPOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAssignPortToIPOperationCompleted); + } + this.InvokeAsync("AssignPortToIP", new object[] { + authUsername, + authPassword, + portID, + ipAddress}, this.AssignPortToIPOperationCompleted, userState); + } + + private void OnAssignPortToIPOperationCompleted(object arg) + { + if ((this.AssignPortToIPCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AssignPortToIPCompleted(this, new AssignPortToIPCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListGateways", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GatewayListResult ListGateways(string AuthUserName, string AuthPassword) + { + object[] results = this.Invoke("ListGateways", new object[] { + AuthUserName, + AuthPassword}); + return ((GatewayListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListGateways(string AuthUserName, string AuthPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListGateways", new object[] { + AuthUserName, + AuthPassword}, callback, asyncState); + } + + /// + public GatewayListResult EndListGateways(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GatewayListResult)(results[0])); + } + + /// + public void ListGatewaysAsync(string AuthUserName, string AuthPassword) + { + this.ListGatewaysAsync(AuthUserName, AuthPassword, null); + } + + /// + public void ListGatewaysAsync(string AuthUserName, string AuthPassword, object userState) + { + if ((this.ListGatewaysOperationCompleted == null)) + { + this.ListGatewaysOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListGatewaysOperationCompleted); + } + this.InvokeAsync("ListGateways", new object[] { + AuthUserName, + AuthPassword}, this.ListGatewaysOperationCompleted, userState); + } + + private void OnListGatewaysOperationCompleted(object arg) + { + if ((this.ListGatewaysCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListGatewaysCompleted(this, new ListGatewaysCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GatewayResult GetGateway(string AuthUserName, string AuthPassword, string guid) + { + object[] results = this.Invoke("GetGateway", new object[] { + AuthUserName, + AuthPassword, + guid}); + return ((GatewayResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetGateway(string AuthUserName, string AuthPassword, string guid, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, callback, asyncState); + } + + /// + public GatewayResult EndGetGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GatewayResult)(results[0])); + } + + /// + public void GetGatewayAsync(string AuthUserName, string AuthPassword, string guid) + { + this.GetGatewayAsync(AuthUserName, AuthPassword, guid, null); + } + + /// + public void GetGatewayAsync(string AuthUserName, string AuthPassword, string guid, object userState) + { + if ((this.GetGatewayOperationCompleted == null)) + { + this.GetGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetGatewayOperationCompleted); + } + this.InvokeAsync("GetGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, this.GetGatewayOperationCompleted, userState); + } + + private void OnGetGatewayOperationCompleted(object arg) + { + if ((this.GetGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetGatewayCompleted(this, new GetGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetGlobalTrustedSenders", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public TrustedSenderListResult GetGlobalTrustedSenders(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetGlobalTrustedSenders", new object[] { + authUsername, + authPassword}); + return ((TrustedSenderListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetGlobalTrustedSenders(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetGlobalTrustedSenders", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public TrustedSenderListResult EndGetGlobalTrustedSenders(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((TrustedSenderListResult)(results[0])); + } + + /// + public void GetGlobalTrustedSendersAsync(string authUsername, string authPassword) + { + this.GetGlobalTrustedSendersAsync(authUsername, authPassword, null); + } + + /// + public void GetGlobalTrustedSendersAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetGlobalTrustedSendersOperationCompleted == null)) + { + this.GetGlobalTrustedSendersOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetGlobalTrustedSendersOperationCompleted); + } + this.InvokeAsync("GetGlobalTrustedSenders", new object[] { + authUsername, + authPassword}, this.GetGlobalTrustedSendersOperationCompleted, userState); + } + + private void OnGetGlobalTrustedSendersOperationCompleted(object arg) + { + if ((this.GetGlobalTrustedSendersCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetGlobalTrustedSendersCompleted(this, new GetGlobalTrustedSendersCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddGlobalTrustedSender", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddGlobalTrustedSender(string authUsername, string authPassword, string addressOrDomain) + { + object[] results = this.Invoke("AddGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddGlobalTrustedSender(string authUsername, string authPassword, string addressOrDomain, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}, callback, asyncState); + } + + /// + public GenericResult EndAddGlobalTrustedSender(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddGlobalTrustedSenderAsync(string authUsername, string authPassword, string addressOrDomain) + { + this.AddGlobalTrustedSenderAsync(authUsername, authPassword, addressOrDomain, null); + } + + /// + public void AddGlobalTrustedSenderAsync(string authUsername, string authPassword, string addressOrDomain, object userState) + { + if ((this.AddGlobalTrustedSenderOperationCompleted == null)) + { + this.AddGlobalTrustedSenderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddGlobalTrustedSenderOperationCompleted); + } + this.InvokeAsync("AddGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}, this.AddGlobalTrustedSenderOperationCompleted, userState); + } + + private void OnAddGlobalTrustedSenderOperationCompleted(object arg) + { + if ((this.AddGlobalTrustedSenderCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddGlobalTrustedSenderCompleted(this, new AddGlobalTrustedSenderCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteGlobalTrustedSender", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteGlobalTrustedSender(string authUsername, string authPassword, string addressOrDomain) + { + object[] results = this.Invoke("DeleteGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteGlobalTrustedSender(string authUsername, string authPassword, string addressOrDomain, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}, callback, asyncState); + } + + /// + public GenericResult EndDeleteGlobalTrustedSender(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteGlobalTrustedSenderAsync(string authUsername, string authPassword, string addressOrDomain) + { + this.DeleteGlobalTrustedSenderAsync(authUsername, authPassword, addressOrDomain, null); + } + + /// + public void DeleteGlobalTrustedSenderAsync(string authUsername, string authPassword, string addressOrDomain, object userState) + { + if ((this.DeleteGlobalTrustedSenderOperationCompleted == null)) + { + this.DeleteGlobalTrustedSenderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteGlobalTrustedSenderOperationCompleted); + } + this.InvokeAsync("DeleteGlobalTrustedSender", new object[] { + authUsername, + authPassword, + addressOrDomain}, this.DeleteGlobalTrustedSenderOperationCompleted, userState); + } + + private void OnDeleteGlobalTrustedSenderOperationCompleted(object arg) + { + if ((this.DeleteGlobalTrustedSenderCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteGlobalTrustedSenderCompleted(this, new DeleteGlobalTrustedSenderCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteGreylistingFilter", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteGreylistingFilter(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string countryCode) + { + object[] results = this.Invoke("DeleteGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + countryCode}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteGreylistingFilter(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string countryCode, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + countryCode}, callback, asyncState); + } + + /// + public GenericResult EndDeleteGreylistingFilter(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteGreylistingFilterAsync(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string countryCode) + { + this.DeleteGreylistingFilterAsync(authUsername, authPassword, filterType, ipRangeStart, ipRangeEnd, ipAddress, countryCode, null); + } + + /// + public void DeleteGreylistingFilterAsync(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string countryCode, object userState) + { + if ((this.DeleteGreylistingFilterOperationCompleted == null)) + { + this.DeleteGreylistingFilterOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteGreylistingFilterOperationCompleted); + } + this.InvokeAsync("DeleteGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + countryCode}, this.DeleteGreylistingFilterOperationCompleted, userState); + } + + private void OnDeleteGreylistingFilterOperationCompleted(object arg) + { + if ((this.DeleteGreylistingFilterCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteGreylistingFilterCompleted(this, new DeleteGreylistingFilterCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetWhitelistEntries", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public WhitelistListResult GetWhitelistEntries(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetWhitelistEntries", new object[] { + authUsername, + authPassword}); + return ((WhitelistListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetWhitelistEntries(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetWhitelistEntries", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public WhitelistListResult EndGetWhitelistEntries(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((WhitelistListResult)(results[0])); + } + + /// + public void GetWhitelistEntriesAsync(string authUsername, string authPassword) + { + this.GetWhitelistEntriesAsync(authUsername, authPassword, null); + } + + /// + public void GetWhitelistEntriesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetWhitelistEntriesOperationCompleted == null)) + { + this.GetWhitelistEntriesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetWhitelistEntriesOperationCompleted); + } + this.InvokeAsync("GetWhitelistEntries", new object[] { + authUsername, + authPassword}, this.GetWhitelistEntriesOperationCompleted, userState); + } + + private void OnGetWhitelistEntriesOperationCompleted(object arg) + { + if ((this.GetWhitelistEntriesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetWhitelistEntriesCompleted(this, new GetWhitelistEntriesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetBlacklistEntries", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public BlacklistListResult GetBlacklistEntries(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetBlacklistEntries", new object[] { + authUsername, + authPassword}); + return ((BlacklistListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetBlacklistEntries(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetBlacklistEntries", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public BlacklistListResult EndGetBlacklistEntries(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((BlacklistListResult)(results[0])); + } + + /// + public void GetBlacklistEntriesAsync(string authUsername, string authPassword) + { + this.GetBlacklistEntriesAsync(authUsername, authPassword, null); + } + + /// + public void GetBlacklistEntriesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetBlacklistEntriesOperationCompleted == null)) + { + this.GetBlacklistEntriesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetBlacklistEntriesOperationCompleted); + } + this.InvokeAsync("GetBlacklistEntries", new object[] { + authUsername, + authPassword}, this.GetBlacklistEntriesOperationCompleted, userState); + } + + private void OnGetBlacklistEntriesOperationCompleted(object arg) + { + if ((this.GetBlacklistEntriesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetBlacklistEntriesCompleted(this, new GetBlacklistEntriesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetBlacklistEntry", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetBlacklistEntry(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool blacklistSMTP, bool blacklistPOP, bool blacklistIMAP, string description) + { + object[] results = this.Invoke("SetBlacklistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + blacklistSMTP, + blacklistPOP, + blacklistIMAP, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetBlacklistEntry(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool blacklistSMTP, bool blacklistPOP, bool blacklistIMAP, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetBlacklistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + blacklistSMTP, + blacklistPOP, + blacklistIMAP, + description}, callback, asyncState); + } + + /// + public GenericResult EndSetBlacklistEntry(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetBlacklistEntryAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool blacklistSMTP, bool blacklistPOP, bool blacklistIMAP, string description) + { + this.SetBlacklistEntryAsync(authUsername, authPassword, ipAddress, ipRangeStart, ipRangeEnd, blacklistSMTP, blacklistPOP, blacklistIMAP, description, null); + } + + /// + public void SetBlacklistEntryAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool blacklistSMTP, bool blacklistPOP, bool blacklistIMAP, string description, object userState) + { + if ((this.SetBlacklistEntryOperationCompleted == null)) + { + this.SetBlacklistEntryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetBlacklistEntryOperationCompleted); + } + this.InvokeAsync("SetBlacklistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + blacklistSMTP, + blacklistPOP, + blacklistIMAP, + description}, this.SetBlacklistEntryOperationCompleted, userState); + } + + private void OnSetBlacklistEntryOperationCompleted(object arg) + { + if ((this.SetBlacklistEntryCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetBlacklistEntryCompleted(this, new SetBlacklistEntryCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetWhitelistEntry", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetWhitelistEntry(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool whitelistSMTP, bool whitelistPOP, bool whitelistIMAP, string description) + { + object[] results = this.Invoke("SetWhitelistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + whitelistSMTP, + whitelistPOP, + whitelistIMAP, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetWhitelistEntry(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool whitelistSMTP, bool whitelistPOP, bool whitelistIMAP, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetWhitelistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + whitelistSMTP, + whitelistPOP, + whitelistIMAP, + description}, callback, asyncState); + } + + /// + public GenericResult EndSetWhitelistEntry(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetWhitelistEntryAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool whitelistSMTP, bool whitelistPOP, bool whitelistIMAP, string description) + { + this.SetWhitelistEntryAsync(authUsername, authPassword, ipAddress, ipRangeStart, ipRangeEnd, whitelistSMTP, whitelistPOP, whitelistIMAP, description, null); + } + + /// + public void SetWhitelistEntryAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, bool whitelistSMTP, bool whitelistPOP, bool whitelistIMAP, string description, object userState) + { + if ((this.SetWhitelistEntryOperationCompleted == null)) + { + this.SetWhitelistEntryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetWhitelistEntryOperationCompleted); + } + this.InvokeAsync("SetWhitelistEntry", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + whitelistSMTP, + whitelistPOP, + whitelistIMAP, + description}, this.SetWhitelistEntryOperationCompleted, userState); + } + + private void OnSetWhitelistEntryOperationCompleted(object arg) + { + if ((this.SetWhitelistEntryCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetWhitelistEntryCompleted(this, new SetWhitelistEntryCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddGreylistingFilter", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddGreylistingFilter(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string description, string countryCode) + { + object[] results = this.Invoke("AddGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + description, + countryCode}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddGreylistingFilter(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string description, string countryCode, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + description, + countryCode}, callback, asyncState); + } + + /// + public GenericResult EndAddGreylistingFilter(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddGreylistingFilterAsync(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string description, string countryCode) + { + this.AddGreylistingFilterAsync(authUsername, authPassword, filterType, ipRangeStart, ipRangeEnd, ipAddress, description, countryCode, null); + } + + /// + public void AddGreylistingFilterAsync(string authUsername, string authPassword, string filterType, string ipRangeStart, string ipRangeEnd, string ipAddress, string description, string countryCode, object userState) + { + if ((this.AddGreylistingFilterOperationCompleted == null)) + { + this.AddGreylistingFilterOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddGreylistingFilterOperationCompleted); + } + this.InvokeAsync("AddGreylistingFilter", new object[] { + authUsername, + authPassword, + filterType, + ipRangeStart, + ipRangeEnd, + ipAddress, + description, + countryCode}, this.AddGreylistingFilterOperationCompleted, userState); + } + + private void OnAddGreylistingFilterOperationCompleted(object arg) + { + if ((this.AddGreylistingFilterCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddGreylistingFilterCompleted(this, new AddGreylistingFilterCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSmtpAuthenticationBypass", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSmtpAuthenticationBypass(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, string description) + { + object[] results = this.Invoke("AddSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + description}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSmtpAuthenticationBypass(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, string description, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + description}, callback, asyncState); + } + + /// + public GenericResult EndAddSmtpAuthenticationBypass(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSmtpAuthenticationBypassAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, string description) + { + this.AddSmtpAuthenticationBypassAsync(authUsername, authPassword, ipAddress, ipRangeStart, ipRangeEnd, description, null); + } + + /// + public void AddSmtpAuthenticationBypassAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, string description, object userState) + { + if ((this.AddSmtpAuthenticationBypassOperationCompleted == null)) + { + this.AddSmtpAuthenticationBypassOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSmtpAuthenticationBypassOperationCompleted); + } + this.InvokeAsync("AddSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd, + description}, this.AddSmtpAuthenticationBypassOperationCompleted, userState); + } + + private void OnAddSmtpAuthenticationBypassOperationCompleted(object arg) + { + if ((this.AddSmtpAuthenticationBypassCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSmtpAuthenticationBypassCompleted(this, new AddSmtpAuthenticationBypassCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteSmtpAuthenticationBypass", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteSmtpAuthenticationBypass(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd) + { + object[] results = this.Invoke("DeleteSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteSmtpAuthenticationBypass(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd}, callback, asyncState); + } + + /// + public GenericResult EndDeleteSmtpAuthenticationBypass(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteSmtpAuthenticationBypassAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd) + { + this.DeleteSmtpAuthenticationBypassAsync(authUsername, authPassword, ipAddress, ipRangeStart, ipRangeEnd, null); + } + + /// + public void DeleteSmtpAuthenticationBypassAsync(string authUsername, string authPassword, string ipAddress, string ipRangeStart, string ipRangeEnd, object userState) + { + if ((this.DeleteSmtpAuthenticationBypassOperationCompleted == null)) + { + this.DeleteSmtpAuthenticationBypassOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteSmtpAuthenticationBypassOperationCompleted); + } + this.InvokeAsync("DeleteSmtpAuthenticationBypass", new object[] { + authUsername, + authPassword, + ipAddress, + ipRangeStart, + ipRangeEnd}, this.DeleteSmtpAuthenticationBypassOperationCompleted, userState); + } + + private void OnDeleteSmtpAuthenticationBypassOperationCompleted(object arg) + { + if ((this.DeleteSmtpAuthenticationBypassCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteSmtpAuthenticationBypassCompleted(this, new DeleteSmtpAuthenticationBypassCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/GetSmtpAuthenticationBypasses", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SMTPAuthBypassListResult GetSmtpAuthenticationBypasses(string authUsername, string authPassword) + { + object[] results = this.Invoke("GetSmtpAuthenticationBypasses", new object[] { + authUsername, + authPassword}); + return ((SMTPAuthBypassListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginGetSmtpAuthenticationBypasses(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("GetSmtpAuthenticationBypasses", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public SMTPAuthBypassListResult EndGetSmtpAuthenticationBypasses(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SMTPAuthBypassListResult)(results[0])); + } + + /// + public void GetSmtpAuthenticationBypassesAsync(string authUsername, string authPassword) + { + this.GetSmtpAuthenticationBypassesAsync(authUsername, authPassword, null); + } + + /// + public void GetSmtpAuthenticationBypassesAsync(string authUsername, string authPassword, object userState) + { + if ((this.GetSmtpAuthenticationBypassesOperationCompleted == null)) + { + this.GetSmtpAuthenticationBypassesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnGetSmtpAuthenticationBypassesOperationCompleted); + } + this.InvokeAsync("GetSmtpAuthenticationBypasses", new object[] { + authUsername, + authPassword}, this.GetSmtpAuthenticationBypassesOperationCompleted, userState); + } + + private void OnGetSmtpAuthenticationBypassesOperationCompleted(object arg) + { + if ((this.GetSmtpAuthenticationBypassesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.GetSmtpAuthenticationBypassesCompleted(this, new GetSmtpAuthenticationBypassesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddGateway(string AuthUserName, string AuthPassword, string address, bool enabled) + { + object[] results = this.Invoke("AddGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddGateway(string AuthUserName, string AuthPassword, string address, bool enabled, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled}, callback, asyncState); + } + + /// + public GenericResult EndAddGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddGatewayAsync(string AuthUserName, string AuthPassword, string address, bool enabled) + { + this.AddGatewayAsync(AuthUserName, AuthPassword, address, enabled, null); + } + + /// + public void AddGatewayAsync(string AuthUserName, string AuthPassword, string address, bool enabled, object userState) + { + if ((this.AddGatewayOperationCompleted == null)) + { + this.AddGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddGatewayOperationCompleted); + } + this.InvokeAsync("AddGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled}, this.AddGatewayOperationCompleted, userState); + } + + private void OnAddGatewayOperationCompleted(object arg) + { + if ((this.AddGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddGatewayCompleted(this, new AddGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSmarterMailGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSmarterMailGateway(string AuthUserName, string AuthPassword, string address, bool enabled, string smUrl, string smUserName, string smPassword) + { + object[] results = this.Invoke("AddSmarterMailGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled, + smUrl, + smUserName, + smPassword}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSmarterMailGateway(string AuthUserName, string AuthPassword, string address, bool enabled, string smUrl, string smUserName, string smPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSmarterMailGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled, + smUrl, + smUserName, + smPassword}, callback, asyncState); + } + + /// + public GenericResult EndAddSmarterMailGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSmarterMailGatewayAsync(string AuthUserName, string AuthPassword, string address, bool enabled, string smUrl, string smUserName, string smPassword) + { + this.AddSmarterMailGatewayAsync(AuthUserName, AuthPassword, address, enabled, smUrl, smUserName, smPassword, null); + } + + /// + public void AddSmarterMailGatewayAsync(string AuthUserName, string AuthPassword, string address, bool enabled, string smUrl, string smUserName, string smPassword, object userState) + { + if ((this.AddSmarterMailGatewayOperationCompleted == null)) + { + this.AddSmarterMailGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSmarterMailGatewayOperationCompleted); + } + this.InvokeAsync("AddSmarterMailGateway", new object[] { + AuthUserName, + AuthPassword, + address, + enabled, + smUrl, + smUserName, + smPassword}, this.AddSmarterMailGatewayOperationCompleted, userState); + } + + private void OnAddSmarterMailGatewayOperationCompleted(object arg) + { + if ((this.AddSmarterMailGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSmarterMailGatewayCompleted(this, new AddSmarterMailGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveGateway(string AuthUserName, string AuthPassword, string guid) + { + object[] results = this.Invoke("RemoveGateway", new object[] { + AuthUserName, + AuthPassword, + guid}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveGateway(string AuthUserName, string AuthPassword, string guid, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, callback, asyncState); + } + + /// + public GenericResult EndRemoveGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveGatewayAsync(string AuthUserName, string AuthPassword, string guid) + { + this.RemoveGatewayAsync(AuthUserName, AuthPassword, guid, null); + } + + /// + public void RemoveGatewayAsync(string AuthUserName, string AuthPassword, string guid, object userState) + { + if ((this.RemoveGatewayOperationCompleted == null)) + { + this.RemoveGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveGatewayOperationCompleted); + } + this.InvokeAsync("RemoveGateway", new object[] { + AuthUserName, + AuthPassword, + guid}, this.RemoveGatewayOperationCompleted, userState); + } + + private void OnRemoveGatewayOperationCompleted(object arg) + { + if ((this.RemoveGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveGatewayCompleted(this, new RemoveGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/UpdateGateway", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult UpdateGateway(string AuthUserName, string AuthPassword, string guid, string address, bool enabled, bool isSmarterMailServer, string smUrl, string smUserName, string smPassword) + { + object[] results = this.Invoke("UpdateGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + address, + enabled, + isSmarterMailServer, + smUrl, + smUserName, + smPassword}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginUpdateGateway(string AuthUserName, string AuthPassword, string guid, string address, bool enabled, bool isSmarterMailServer, string smUrl, string smUserName, string smPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("UpdateGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + address, + enabled, + isSmarterMailServer, + smUrl, + smUserName, + smPassword}, callback, asyncState); + } + + /// + public GenericResult EndUpdateGateway(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void UpdateGatewayAsync(string AuthUserName, string AuthPassword, string guid, string address, bool enabled, bool isSmarterMailServer, string smUrl, string smUserName, string smPassword) + { + this.UpdateGatewayAsync(AuthUserName, AuthPassword, guid, address, enabled, isSmarterMailServer, smUrl, smUserName, smPassword, null); + } + + /// + public void UpdateGatewayAsync(string AuthUserName, string AuthPassword, string guid, string address, bool enabled, bool isSmarterMailServer, string smUrl, string smUserName, string smPassword, object userState) + { + if ((this.UpdateGatewayOperationCompleted == null)) + { + this.UpdateGatewayOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateGatewayOperationCompleted); + } + this.InvokeAsync("UpdateGateway", new object[] { + AuthUserName, + AuthPassword, + guid, + address, + enabled, + isSmarterMailServer, + smUrl, + smUserName, + smPassword}, this.UpdateGatewayOperationCompleted, userState); + } + + private void OnUpdateGatewayOperationCompleted(object arg) + { + if ((this.UpdateGatewayCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.UpdateGatewayCompleted(this, new UpdateGatewayCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListSystemAdmins", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public SystemAdminListResult ListSystemAdmins(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListSystemAdmins", new object[] { + authUsername, + authPassword}); + return ((SystemAdminListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListSystemAdmins(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListSystemAdmins", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public SystemAdminListResult EndListSystemAdmins(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((SystemAdminListResult)(results[0])); + } + + /// + public void ListSystemAdminsAsync(string authUsername, string authPassword) + { + this.ListSystemAdminsAsync(authUsername, authPassword, null); + } + + /// + public void ListSystemAdminsAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListSystemAdminsOperationCompleted == null)) + { + this.ListSystemAdminsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListSystemAdminsOperationCompleted); + } + this.InvokeAsync("ListSystemAdmins", new object[] { + authUsername, + authPassword}, this.ListSystemAdminsOperationCompleted, userState); + } + + private void OnListSystemAdminsOperationCompleted(object arg) + { + if ((this.ListSystemAdminsCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListSystemAdminsCompleted(this, new ListSystemAdminsCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/SetSystemAdminPassword", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult SetSystemAdminPassword(string authUsername, string authPassword, string systemAdminUsername, string newPassword) + { + object[] results = this.Invoke("SetSystemAdminPassword", new object[] { + authUsername, + authPassword, + systemAdminUsername, + newPassword}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginSetSystemAdminPassword(string authUsername, string authPassword, string systemAdminUsername, string newPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("SetSystemAdminPassword", new object[] { + authUsername, + authPassword, + systemAdminUsername, + newPassword}, callback, asyncState); + } + + /// + public GenericResult EndSetSystemAdminPassword(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void SetSystemAdminPasswordAsync(string authUsername, string authPassword, string systemAdminUsername, string newPassword) + { + this.SetSystemAdminPasswordAsync(authUsername, authPassword, systemAdminUsername, newPassword, null); + } + + /// + public void SetSystemAdminPasswordAsync(string authUsername, string authPassword, string systemAdminUsername, string newPassword, object userState) + { + if ((this.SetSystemAdminPasswordOperationCompleted == null)) + { + this.SetSystemAdminPasswordOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetSystemAdminPasswordOperationCompleted); + } + this.InvokeAsync("SetSystemAdminPassword", new object[] { + authUsername, + authPassword, + systemAdminUsername, + newPassword}, this.SetSystemAdminPasswordOperationCompleted, userState); + } + + private void OnSetSystemAdminPasswordOperationCompleted(object arg) + { + if ((this.SetSystemAdminPasswordCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.SetSystemAdminPasswordCompleted(this, new SetSystemAdminPasswordCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteSystemAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteSystemAdmin(string authUsername, string authPassword, string systemAdminUsername) + { + object[] results = this.Invoke("DeleteSystemAdmin", new object[] { + authUsername, + authPassword, + systemAdminUsername}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteSystemAdmin(string authUsername, string authPassword, string systemAdminUsername, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteSystemAdmin", new object[] { + authUsername, + authPassword, + systemAdminUsername}, callback, asyncState); + } + + /// + public GenericResult EndDeleteSystemAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteSystemAdminAsync(string authUsername, string authPassword, string systemAdminUsername) + { + this.DeleteSystemAdminAsync(authUsername, authPassword, systemAdminUsername, null); + } + + /// + public void DeleteSystemAdminAsync(string authUsername, string authPassword, string systemAdminUsername, object userState) + { + if ((this.DeleteSystemAdminOperationCompleted == null)) + { + this.DeleteSystemAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteSystemAdminOperationCompleted); + } + this.InvokeAsync("DeleteSystemAdmin", new object[] { + authUsername, + authPassword, + systemAdminUsername}, this.DeleteSystemAdminOperationCompleted, userState); + } + + private void OnDeleteSystemAdminOperationCompleted(object arg) + { + if ((this.DeleteSystemAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteSystemAdminCompleted(this, new DeleteSystemAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddSystemAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddSystemAdmin(string authUsername, string authPassword, string newAdminUsername, string newAdminPassword, string newAdminDescription) + { + object[] results = this.Invoke("AddSystemAdmin", new object[] { + authUsername, + authPassword, + newAdminUsername, + newAdminPassword, + newAdminDescription}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddSystemAdmin(string authUsername, string authPassword, string newAdminUsername, string newAdminPassword, string newAdminDescription, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddSystemAdmin", new object[] { + authUsername, + authPassword, + newAdminUsername, + newAdminPassword, + newAdminDescription}, callback, asyncState); + } + + /// + public GenericResult EndAddSystemAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddSystemAdminAsync(string authUsername, string authPassword, string newAdminUsername, string newAdminPassword, string newAdminDescription) + { + this.AddSystemAdminAsync(authUsername, authPassword, newAdminUsername, newAdminPassword, newAdminDescription, null); + } + + /// + public void AddSystemAdminAsync(string authUsername, string authPassword, string newAdminUsername, string newAdminPassword, string newAdminDescription, object userState) + { + if ((this.AddSystemAdminOperationCompleted == null)) + { + this.AddSystemAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSystemAdminOperationCompleted); + } + this.InvokeAsync("AddSystemAdmin", new object[] { + authUsername, + authPassword, + newAdminUsername, + newAdminPassword, + newAdminDescription}, this.AddSystemAdminOperationCompleted, userState); + } + + private void OnAddSystemAdminOperationCompleted(object arg) + { + if ((this.AddSystemAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddSystemAdminCompleted(this, new AddSystemAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddIPRestrictionToSystemAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddIPRestrictionToSystemAdmin(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, string restrictionDescription) + { + object[] results = this.Invoke("AddIPRestrictionToSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange, + restrictionDescription}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddIPRestrictionToSystemAdmin(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, string restrictionDescription, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddIPRestrictionToSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange, + restrictionDescription}, callback, asyncState); + } + + /// + public GenericResult EndAddIPRestrictionToSystemAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddIPRestrictionToSystemAdminAsync(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, string restrictionDescription) + { + this.AddIPRestrictionToSystemAdminAsync(authUsername, authPassword, adminUsername, ipAddressOrRange, restrictionDescription, null); + } + + /// + public void AddIPRestrictionToSystemAdminAsync(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, string restrictionDescription, object userState) + { + if ((this.AddIPRestrictionToSystemAdminOperationCompleted == null)) + { + this.AddIPRestrictionToSystemAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddIPRestrictionToSystemAdminOperationCompleted); + } + this.InvokeAsync("AddIPRestrictionToSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange, + restrictionDescription}, this.AddIPRestrictionToSystemAdminOperationCompleted, userState); + } + + private void OnAddIPRestrictionToSystemAdminOperationCompleted(object arg) + { + if ((this.AddIPRestrictionToSystemAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddIPRestrictionToSystemAdminCompleted(this, new AddIPRestrictionToSystemAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/RemoveIPRestrictionFromSystemAdmin", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult RemoveIPRestrictionFromSystemAdmin(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange) + { + object[] results = this.Invoke("RemoveIPRestrictionFromSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginRemoveIPRestrictionFromSystemAdmin(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("RemoveIPRestrictionFromSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange}, callback, asyncState); + } + + /// + public GenericResult EndRemoveIPRestrictionFromSystemAdmin(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void RemoveIPRestrictionFromSystemAdminAsync(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange) + { + this.RemoveIPRestrictionFromSystemAdminAsync(authUsername, authPassword, adminUsername, ipAddressOrRange, null); + } + + /// + public void RemoveIPRestrictionFromSystemAdminAsync(string authUsername, string authPassword, string adminUsername, string ipAddressOrRange, object userState) + { + if ((this.RemoveIPRestrictionFromSystemAdminOperationCompleted == null)) + { + this.RemoveIPRestrictionFromSystemAdminOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRemoveIPRestrictionFromSystemAdminOperationCompleted); + } + this.InvokeAsync("RemoveIPRestrictionFromSystemAdmin", new object[] { + authUsername, + authPassword, + adminUsername, + ipAddressOrRange}, this.RemoveIPRestrictionFromSystemAdminOperationCompleted, userState); + } + + private void OnRemoveIPRestrictionFromSystemAdminOperationCompleted(object arg) + { + if ((this.RemoveIPRestrictionFromSystemAdminCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.RemoveIPRestrictionFromSystemAdminCompleted(this, new RemoveIPRestrictionFromSystemAdminCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddHostname", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddHostname(string authUsername, string authPassword, string hostname, string ipAddress) + { + object[] results = this.Invoke("AddHostname", new object[] { + authUsername, + authPassword, + hostname, + ipAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddHostname(string authUsername, string authPassword, string hostname, string ipAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddHostname", new object[] { + authUsername, + authPassword, + hostname, + ipAddress}, callback, asyncState); + } + + /// + public GenericResult EndAddHostname(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddHostnameAsync(string authUsername, string authPassword, string hostname, string ipAddress) + { + this.AddHostnameAsync(authUsername, authPassword, hostname, ipAddress, null); + } + + /// + public void AddHostnameAsync(string authUsername, string authPassword, string hostname, string ipAddress, object userState) + { + if ((this.AddHostnameOperationCompleted == null)) + { + this.AddHostnameOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddHostnameOperationCompleted); + } + this.InvokeAsync("AddHostname", new object[] { + authUsername, + authPassword, + hostname, + ipAddress}, this.AddHostnameOperationCompleted, userState); + } + + private void OnAddHostnameOperationCompleted(object arg) + { + if ((this.AddHostnameCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddHostnameCompleted(this, new AddHostnameCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteHostname", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteHostname(string authUsername, string authPassword, string ipAddress) + { + object[] results = this.Invoke("DeleteHostname", new object[] { + authUsername, + authPassword, + ipAddress}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteHostname(string authUsername, string authPassword, string ipAddress, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteHostname", new object[] { + authUsername, + authPassword, + ipAddress}, callback, asyncState); + } + + /// + public GenericResult EndDeleteHostname(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteHostnameAsync(string authUsername, string authPassword, string ipAddress) + { + this.DeleteHostnameAsync(authUsername, authPassword, ipAddress, null); + } + + /// + public void DeleteHostnameAsync(string authUsername, string authPassword, string ipAddress, object userState) + { + if ((this.DeleteHostnameOperationCompleted == null)) + { + this.DeleteHostnameOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteHostnameOperationCompleted); + } + this.InvokeAsync("DeleteHostname", new object[] { + authUsername, + authPassword, + ipAddress}, this.DeleteHostnameOperationCompleted, userState); + } + + private void OnDeleteHostnameOperationCompleted(object arg) + { + if ((this.DeleteHostnameCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteHostnameCompleted(this, new DeleteHostnameCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListHostnames", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public HostnameListResult ListHostnames(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListHostnames", new object[] { + authUsername, + authPassword}); + return ((HostnameListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListHostnames(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListHostnames", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public HostnameListResult EndListHostnames(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((HostnameListResult)(results[0])); + } + + /// + public void ListHostnamesAsync(string authUsername, string authPassword) + { + this.ListHostnamesAsync(authUsername, authPassword, null); + } + + /// + public void ListHostnamesAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListHostnamesOperationCompleted == null)) + { + this.ListHostnamesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListHostnamesOperationCompleted); + } + this.InvokeAsync("ListHostnames", new object[] { + authUsername, + authPassword}, this.ListHostnamesOperationCompleted, userState); + } + + private void OnListHostnamesOperationCompleted(object arg) + { + if ((this.ListHostnamesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListHostnamesCompleted(this, new ListHostnamesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddFolderAutocleanRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddFolderAutocleanRule(string authUsername, string authPassword, string folder, bool enableRule, string type, int sizeBeforeAutoClean, int sizeAfterClean, int mailAgeInDays) + { + object[] results = this.Invoke("AddFolderAutocleanRule", new object[] { + authUsername, + authPassword, + folder, + enableRule, + type, + sizeBeforeAutoClean, + sizeAfterClean, + mailAgeInDays}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddFolderAutocleanRule(string authUsername, string authPassword, string folder, bool enableRule, string type, int sizeBeforeAutoClean, int sizeAfterClean, int mailAgeInDays, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddFolderAutocleanRule", new object[] { + authUsername, + authPassword, + folder, + enableRule, + type, + sizeBeforeAutoClean, + sizeAfterClean, + mailAgeInDays}, callback, asyncState); + } + + /// + public GenericResult EndAddFolderAutocleanRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddFolderAutocleanRuleAsync(string authUsername, string authPassword, string folder, bool enableRule, string type, int sizeBeforeAutoClean, int sizeAfterClean, int mailAgeInDays) + { + this.AddFolderAutocleanRuleAsync(authUsername, authPassword, folder, enableRule, type, sizeBeforeAutoClean, sizeAfterClean, mailAgeInDays, null); + } + + /// + public void AddFolderAutocleanRuleAsync(string authUsername, string authPassword, string folder, bool enableRule, string type, int sizeBeforeAutoClean, int sizeAfterClean, int mailAgeInDays, object userState) + { + if ((this.AddFolderAutocleanRuleOperationCompleted == null)) + { + this.AddFolderAutocleanRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddFolderAutocleanRuleOperationCompleted); + } + this.InvokeAsync("AddFolderAutocleanRule", new object[] { + authUsername, + authPassword, + folder, + enableRule, + type, + sizeBeforeAutoClean, + sizeAfterClean, + mailAgeInDays}, this.AddFolderAutocleanRuleOperationCompleted, userState); + } + + private void OnAddFolderAutocleanRuleOperationCompleted(object arg) + { + if ((this.AddFolderAutocleanRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddFolderAutocleanRuleCompleted(this, new AddFolderAutocleanRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteFolderAutoCleanRule", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteFolderAutoCleanRule(string authUsername, string authPassword, string id) + { + object[] results = this.Invoke("DeleteFolderAutoCleanRule", new object[] { + authUsername, + authPassword, + id}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteFolderAutoCleanRule(string authUsername, string authPassword, string id, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteFolderAutoCleanRule", new object[] { + authUsername, + authPassword, + id}, callback, asyncState); + } + + /// + public GenericResult EndDeleteFolderAutoCleanRule(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteFolderAutoCleanRuleAsync(string authUsername, string authPassword, string id) + { + this.DeleteFolderAutoCleanRuleAsync(authUsername, authPassword, id, null); + } + + /// + public void DeleteFolderAutoCleanRuleAsync(string authUsername, string authPassword, string id, object userState) + { + if ((this.DeleteFolderAutoCleanRuleOperationCompleted == null)) + { + this.DeleteFolderAutoCleanRuleOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteFolderAutoCleanRuleOperationCompleted); + } + this.InvokeAsync("DeleteFolderAutoCleanRule", new object[] { + authUsername, + authPassword, + id}, this.DeleteFolderAutoCleanRuleOperationCompleted, userState); + } + + private void OnDeleteFolderAutoCleanRuleOperationCompleted(object arg) + { + if ((this.DeleteFolderAutoCleanRuleCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteFolderAutoCleanRuleCompleted(this, new DeleteFolderAutoCleanRuleCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListFolderAutoCleanRules", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public FolderAutoCleanRuleListResult ListFolderAutoCleanRules(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListFolderAutoCleanRules", new object[] { + authUsername, + authPassword}); + return ((FolderAutoCleanRuleListResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListFolderAutoCleanRules(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListFolderAutoCleanRules", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public FolderAutoCleanRuleListResult EndListFolderAutoCleanRules(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((FolderAutoCleanRuleListResult)(results[0])); + } + + /// + public void ListFolderAutoCleanRulesAsync(string authUsername, string authPassword) + { + this.ListFolderAutoCleanRulesAsync(authUsername, authPassword, null); + } + + /// + public void ListFolderAutoCleanRulesAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListFolderAutoCleanRulesOperationCompleted == null)) + { + this.ListFolderAutoCleanRulesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListFolderAutoCleanRulesOperationCompleted); + } + this.InvokeAsync("ListFolderAutoCleanRules", new object[] { + authUsername, + authPassword}, this.ListFolderAutoCleanRulesOperationCompleted, userState); + } + + private void OnListFolderAutoCleanRulesOperationCompleted(object arg) + { + if ((this.ListFolderAutoCleanRulesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListFolderAutoCleanRulesCompleted(this, new ListFolderAutoCleanRulesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/AddForwardingBlacklistEntry", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult AddForwardingBlacklistEntry(string authUsername, string authPassword, string domainName) + { + object[] results = this.Invoke("AddForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginAddForwardingBlacklistEntry(string authUsername, string authPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("AddForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}, callback, asyncState); + } + + /// + public GenericResult EndAddForwardingBlacklistEntry(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void AddForwardingBlacklistEntryAsync(string authUsername, string authPassword, string domainName) + { + this.AddForwardingBlacklistEntryAsync(authUsername, authPassword, domainName, null); + } + + /// + public void AddForwardingBlacklistEntryAsync(string authUsername, string authPassword, string domainName, object userState) + { + if ((this.AddForwardingBlacklistEntryOperationCompleted == null)) + { + this.AddForwardingBlacklistEntryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddForwardingBlacklistEntryOperationCompleted); + } + this.InvokeAsync("AddForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}, this.AddForwardingBlacklistEntryOperationCompleted, userState); + } + + private void OnAddForwardingBlacklistEntryOperationCompleted(object arg) + { + if ((this.AddForwardingBlacklistEntryCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.AddForwardingBlacklistEntryCompleted(this, new AddForwardingBlacklistEntryCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/DeleteForwardingBlacklistEntry", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public GenericResult DeleteForwardingBlacklistEntry(string authUsername, string authPassword, string domainName) + { + object[] results = this.Invoke("DeleteForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}); + return ((GenericResult)(results[0])); + } + + /// + public System.IAsyncResult BeginDeleteForwardingBlacklistEntry(string authUsername, string authPassword, string domainName, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("DeleteForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}, callback, asyncState); + } + + /// + public GenericResult EndDeleteForwardingBlacklistEntry(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((GenericResult)(results[0])); + } + + /// + public void DeleteForwardingBlacklistEntryAsync(string authUsername, string authPassword, string domainName) + { + this.DeleteForwardingBlacklistEntryAsync(authUsername, authPassword, domainName, null); + } + + /// + public void DeleteForwardingBlacklistEntryAsync(string authUsername, string authPassword, string domainName, object userState) + { + if ((this.DeleteForwardingBlacklistEntryOperationCompleted == null)) + { + this.DeleteForwardingBlacklistEntryOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteForwardingBlacklistEntryOperationCompleted); + } + this.InvokeAsync("DeleteForwardingBlacklistEntry", new object[] { + authUsername, + authPassword, + domainName}, this.DeleteForwardingBlacklistEntryOperationCompleted, userState); + } + + private void OnDeleteForwardingBlacklistEntryOperationCompleted(object arg) + { + if ((this.DeleteForwardingBlacklistEntryCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.DeleteForwardingBlacklistEntryCompleted(this, new DeleteForwardingBlacklistEntryCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tempuri.org/ListForwardingBlacklistEntries", RequestNamespace = "http://tempuri.org/", ResponseNamespace = "http://tempuri.org/", Use = System.Web.Services.Description.SoapBindingUse.Literal, ParameterStyle = System.Web.Services.Protocols.SoapParameterStyle.Wrapped)] + public ForwardingBlacklistRuleResult ListForwardingBlacklistEntries(string authUsername, string authPassword) + { + object[] results = this.Invoke("ListForwardingBlacklistEntries", new object[] { + authUsername, + authPassword}); + return ((ForwardingBlacklistRuleResult)(results[0])); + } + + /// + public System.IAsyncResult BeginListForwardingBlacklistEntries(string authUsername, string authPassword, System.AsyncCallback callback, object asyncState) + { + return this.BeginInvoke("ListForwardingBlacklistEntries", new object[] { + authUsername, + authPassword}, callback, asyncState); + } + + /// + public ForwardingBlacklistRuleResult EndListForwardingBlacklistEntries(System.IAsyncResult asyncResult) + { + object[] results = this.EndInvoke(asyncResult); + return ((ForwardingBlacklistRuleResult)(results[0])); + } + + /// + public void ListForwardingBlacklistEntriesAsync(string authUsername, string authPassword) + { + this.ListForwardingBlacklistEntriesAsync(authUsername, authPassword, null); + } + + /// + public void ListForwardingBlacklistEntriesAsync(string authUsername, string authPassword, object userState) + { + if ((this.ListForwardingBlacklistEntriesOperationCompleted == null)) + { + this.ListForwardingBlacklistEntriesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnListForwardingBlacklistEntriesOperationCompleted); + } + this.InvokeAsync("ListForwardingBlacklistEntries", new object[] { + authUsername, + authPassword}, this.ListForwardingBlacklistEntriesOperationCompleted, userState); + } + + private void OnListForwardingBlacklistEntriesOperationCompleted(object arg) + { + if ((this.ListForwardingBlacklistEntriesCompleted != null)) + { + System.Web.Services.Protocols.InvokeCompletedEventArgs invokeArgs = ((System.Web.Services.Protocols.InvokeCompletedEventArgs)(arg)); + this.ListForwardingBlacklistEntriesCompleted(this, new ListForwardingBlacklistEntriesCompletedEventArgs(invokeArgs.Results, invokeArgs.Error, invokeArgs.Cancelled, invokeArgs.UserState)); + } + } + + /// + public new void CancelAsync(object userState) + { + base.CancelAsync(userState); + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class ForwardingBlacklistRuleResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] blacklistedDomainsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] BlacklistedDomains + { + get + { + return this.blacklistedDomainsField; + } + set + { + this.blacklistedDomainsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class FolderAutoCleanRuleResult + { + + private bool enabledField; + + private string idField; + + private int sizeBeforeCleanInMBField; + + private int sizeAfterCleanInMBField; + + private int mailAgeInDaysField; + + private string typeField; + + /// + public bool Enabled + { + get + { + return this.enabledField; + } + set + { + this.enabledField = value; + } + } + + /// + public string ID + { + get + { + return this.idField; + } + set + { + this.idField = value; + } + } + + /// + public int SizeBeforeCleanInMB + { + get + { + return this.sizeBeforeCleanInMBField; + } + set + { + this.sizeBeforeCleanInMBField = value; + } + } + + /// + public int SizeAfterCleanInMB + { + get + { + return this.sizeAfterCleanInMBField; + } + set + { + this.sizeAfterCleanInMBField = value; + } + } + + /// + public int MailAgeInDays + { + get + { + return this.mailAgeInDaysField; + } + set + { + this.mailAgeInDaysField = value; + } + } + + /// + public string Type + { + get + { + return this.typeField; + } + set + { + this.typeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class FolderAutoCleanRuleListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private FolderAutoCleanRuleResult[] rulesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public FolderAutoCleanRuleResult[] Rules + { + get + { + return this.rulesField; + } + set + { + this.rulesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class HostnameResult + { + + private string iPAddressField; + + private string hostnameField; + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string Hostname + { + get + { + return this.hostnameField; + } + set + { + this.hostnameField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class HostnameListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private HostnameResult[] hostnamesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public HostnameResult[] Hostnames + { + get + { + return this.hostnamesField; + } + set + { + this.hostnamesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SystemAdminResult + { + + private string idField; + + private string usernameField; + + private bool isPrimaryAdminField; + + private bool restrictedByIpField; + + private System.DateTime dateCreatedField; + + private string descriptionField; + + /// + public string ID + { + get + { + return this.idField; + } + set + { + this.idField = value; + } + } + + /// + public string Username + { + get + { + return this.usernameField; + } + set + { + this.usernameField = value; + } + } + + /// + public bool IsPrimaryAdmin + { + get + { + return this.isPrimaryAdminField; + } + set + { + this.isPrimaryAdminField = value; + } + } + + /// + public bool RestrictedByIp + { + get + { + return this.restrictedByIpField; + } + set + { + this.restrictedByIpField = value; + } + } + + /// + public System.DateTime DateCreated + { + get + { + return this.dateCreatedField; + } + set + { + this.dateCreatedField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SystemAdminListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private SystemAdminResult[] adminsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public SystemAdminResult[] Admins + { + get + { + return this.adminsField; + } + set + { + this.adminsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SMTPAuthBypassResult + { + + private string iPAddressField; + + private string iPRangeStartField; + + private string iPRangeEndField; + + private string descriptionField; + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string IPRangeStart + { + get + { + return this.iPRangeStartField; + } + set + { + this.iPRangeStartField = value; + } + } + + /// + public string IPRangeEnd + { + get + { + return this.iPRangeEndField; + } + set + { + this.iPRangeEndField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SMTPAuthBypassListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private SMTPAuthBypassResult[] entriesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public SMTPAuthBypassResult[] Entries + { + get + { + return this.entriesField; + } + set + { + this.entriesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class BlacklistResult + { + + private string iPAddressField; + + private string iPRangeStartField; + + private string iPRangeEndField; + + private string descriptionField; + + private bool pOPBlacklistedField; + + private bool iMAPBlacklistedField; + + private bool sMTPBlacklistedField; + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string IPRangeStart + { + get + { + return this.iPRangeStartField; + } + set + { + this.iPRangeStartField = value; + } + } + + /// + public string IPRangeEnd + { + get + { + return this.iPRangeEndField; + } + set + { + this.iPRangeEndField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + + /// + public bool POPBlacklisted + { + get + { + return this.pOPBlacklistedField; + } + set + { + this.pOPBlacklistedField = value; + } + } + + /// + public bool IMAPBlacklisted + { + get + { + return this.iMAPBlacklistedField; + } + set + { + this.iMAPBlacklistedField = value; + } + } + + /// + public bool SMTPBlacklisted + { + get + { + return this.sMTPBlacklistedField; + } + set + { + this.sMTPBlacklistedField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class BlacklistListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private BlacklistResult[] entriesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public BlacklistResult[] Entries + { + get + { + return this.entriesField; + } + set + { + this.entriesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class WhitelistResult + { + + private string iPAddressField; + + private string iPRangeStartField; + + private string iPRangeEndField; + + private string descriptionField; + + private bool pOPWhitelistedField; + + private bool iMAPWhitelistedField; + + private bool sMTPWhitelistedField; + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string IPRangeStart + { + get + { + return this.iPRangeStartField; + } + set + { + this.iPRangeStartField = value; + } + } + + /// + public string IPRangeEnd + { + get + { + return this.iPRangeEndField; + } + set + { + this.iPRangeEndField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + + /// + public bool POPWhitelisted + { + get + { + return this.pOPWhitelistedField; + } + set + { + this.pOPWhitelistedField = value; + } + } + + /// + public bool IMAPWhitelisted + { + get + { + return this.iMAPWhitelistedField; + } + set + { + this.iMAPWhitelistedField = value; + } + } + + /// + public bool SMTPWhitelisted + { + get + { + return this.sMTPWhitelistedField; + } + set + { + this.sMTPWhitelistedField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class WhitelistListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private WhitelistResult[] entriesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public WhitelistResult[] Entries + { + get + { + return this.entriesField; + } + set + { + this.entriesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class TrustedSenderListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] trustedSendersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] TrustedSenders + { + get + { + return this.trustedSendersField; + } + set + { + this.trustedSendersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class GatewayResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string guidField; + + private string gatewayAddressField; + + private bool enabledField; + + private bool isSmarterMailServerField; + + private string smUrlField; + + private string smUserNameField; + + private string smPasswordField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string guid + { + get + { + return this.guidField; + } + set + { + this.guidField = value; + } + } + + /// + public string gatewayAddress + { + get + { + return this.gatewayAddressField; + } + set + { + this.gatewayAddressField = value; + } + } + + /// + public bool enabled + { + get + { + return this.enabledField; + } + set + { + this.enabledField = value; + } + } + + /// + public bool isSmarterMailServer + { + get + { + return this.isSmarterMailServerField; + } + set + { + this.isSmarterMailServerField = value; + } + } + + /// + public string smUrl + { + get + { + return this.smUrlField; + } + set + { + this.smUrlField = value; + } + } + + /// + public string smUserName + { + get + { + return this.smUserNameField; + } + set + { + this.smUserNameField = value; + } + } + + /// + public string smPassword + { + get + { + return this.smPasswordField; + } + set + { + this.smPasswordField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class GatewayListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private GatewayResult[] gatewaysField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public GatewayResult[] gateways + { + get + { + return this.gatewaysField; + } + set + { + this.gatewaysField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class GreylistingFilterResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string filterTypeField; + + private string iPRangeStartField; + + private string iPRangeEndField; + + private string iPAddressField; + + private string descriptionField; + + private string countryCodeField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string FilterType + { + get + { + return this.filterTypeField; + } + set + { + this.filterTypeField = value; + } + } + + /// + public string IPRangeStart + { + get + { + return this.iPRangeStartField; + } + set + { + this.iPRangeStartField = value; + } + } + + /// + public string IPRangeEnd + { + get + { + return this.iPRangeEndField; + } + set + { + this.iPRangeEndField = value; + } + } + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + + /// + public string CountryCode + { + get + { + return this.countryCodeField; + } + set + { + this.countryCodeField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class GreylistingFilterListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private GreylistingFilterResult[] filtersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public GreylistingFilterResult[] Filters + { + get + { + return this.filtersField; + } + set + { + this.filtersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class MessageCountResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private int messageCountField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public int messageCount + { + get + { + return this.messageCountField; + } + set + { + this.messageCountField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class RequestSettingsResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string[] keyValuePairsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string[] KeyValuePairs + { + get + { + return this.keyValuePairsField; + } + set + { + this.keyValuePairsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SpamAssassinServerResult + { + + private string nameField; + + private string iPAddressField; + + private int portField; + + private int consecutiveFailuresField; + + private bool enabledField; + + private int totalConnectionsField; + + /// + public string Name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public int Port + { + get + { + return this.portField; + } + set + { + this.portField = value; + } + } + + /// + public int ConsecutiveFailures + { + get + { + return this.consecutiveFailuresField; + } + set + { + this.consecutiveFailuresField = value; + } + } + + /// + public bool Enabled + { + get + { + return this.enabledField; + } + set + { + this.enabledField = value; + } + } + + /// + public int TotalConnections + { + get + { + return this.totalConnectionsField; + } + set + { + this.totalConnectionsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SpamAssassinServerListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private SpamAssassinServerResult[] serversField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public SpamAssassinServerResult[] Servers + { + get + { + return this.serversField; + } + set + { + this.serversField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class InternalSpammerNotificationAbuseDetectionRuleResult + { + + private int timeframeField; + + private int messagesBeforeNotifyField; + + private string emailAddressToNotifyField; + + private string descriptionField; + + /// + public int Timeframe + { + get + { + return this.timeframeField; + } + set + { + this.timeframeField = value; + } + } + + /// + public int MessagesBeforeNotify + { + get + { + return this.messagesBeforeNotifyField; + } + set + { + this.messagesBeforeNotifyField = value; + } + } + + /// + public string EmailAddressToNotify + { + get + { + return this.emailAddressToNotifyField; + } + set + { + this.emailAddressToNotifyField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class InternalSpammerNotificationAbuseDetectionRulesListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private InternalSpammerNotificationAbuseDetectionRuleResult[] rulesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public InternalSpammerNotificationAbuseDetectionRuleResult[] Rules + { + get + { + return this.rulesField; + } + set + { + this.rulesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class HarvestingAbuseDetectionRuleResult + { + + private int timeframeField; + + private int badSessionsBeforeBlockField; + + private int timeToBlockField; + + private string descriptionField; + + /// + public int Timeframe + { + get + { + return this.timeframeField; + } + set + { + this.timeframeField = value; + } + } + + /// + public int BadSessionsBeforeBlock + { + get + { + return this.badSessionsBeforeBlockField; + } + set + { + this.badSessionsBeforeBlockField = value; + } + } + + /// + public int TimeToBlock + { + get + { + return this.timeToBlockField; + } + set + { + this.timeToBlockField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class HarvestingAbuseDetectionRulesListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private HarvestingAbuseDetectionRuleResult[] rulesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public HarvestingAbuseDetectionRuleResult[] Rules + { + get + { + return this.rulesField; + } + set + { + this.rulesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DOSAbuseDetectionRuleResult + { + + private string serviceField; + + private int timeframeField; + + private int connectionsBeforeBlockField; + + private int timeToBlockField; + + private string descriptionField; + + /// + public string Service + { + get + { + return this.serviceField; + } + set + { + this.serviceField = value; + } + } + + /// + public int Timeframe + { + get + { + return this.timeframeField; + } + set + { + this.timeframeField = value; + } + } + + /// + public int ConnectionsBeforeBlock + { + get + { + return this.connectionsBeforeBlockField; + } + set + { + this.connectionsBeforeBlockField = value; + } + } + + /// + public int TimeToBlock + { + get + { + return this.timeToBlockField; + } + set + { + this.timeToBlockField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class DOSAbuseDetectionRulesListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private DOSAbuseDetectionRuleResult[] rulesField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public DOSAbuseDetectionRuleResult[] Rules + { + get + { + return this.rulesField; + } + set + { + this.rulesField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class IncomingGatewayListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private IncomingGatewayAttributes[] incGatewaysField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + [System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = false)] + public IncomingGatewayAttributes[] incGateways + { + get + { + return this.incGatewaysField; + } + set + { + this.incGatewaysField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class IncomingGatewayAttributes + { + + private string guidField; + + private string gatewayModeField; + + private string iPAddressField; + + private string iPStartRangeField; + + private string iPEndRangeField; + + private string userVerifyTypeField; + + private string webserviceURLField; + + private string domainVerifyTypeField; + + private string[] domainsToForwardField; + + private bool enableSpamActionsField; + + private string spamLowActionField; + + private string spamLowArgsField; + + private string spamMedActionField; + + private string spamMedArgsField; + + private string spamHighActionField; + + private string spamHighArgsField; + + private bool smarterMailModeField; + + private string smarterMailURLField; + + private string authSmarterMailUserNameField; + + private string authSmarterMailPasswordField; + + /// + public string guid + { + get + { + return this.guidField; + } + set + { + this.guidField = value; + } + } + + /// + public string gatewayMode + { + get + { + return this.gatewayModeField; + } + set + { + this.gatewayModeField = value; + } + } + + /// + public string IPAddress + { + get + { + return this.iPAddressField; + } + set + { + this.iPAddressField = value; + } + } + + /// + public string IPStartRange + { + get + { + return this.iPStartRangeField; + } + set + { + this.iPStartRangeField = value; + } + } + + /// + public string IPEndRange + { + get + { + return this.iPEndRangeField; + } + set + { + this.iPEndRangeField = value; + } + } + + /// + public string userVerifyType + { + get + { + return this.userVerifyTypeField; + } + set + { + this.userVerifyTypeField = value; + } + } + + /// + public string webserviceURL + { + get + { + return this.webserviceURLField; + } + set + { + this.webserviceURLField = value; + } + } + + /// + public string domainVerifyType + { + get + { + return this.domainVerifyTypeField; + } + set + { + this.domainVerifyTypeField = value; + } + } + + /// + public string[] domainsToForward + { + get + { + return this.domainsToForwardField; + } + set + { + this.domainsToForwardField = value; + } + } + + /// + public bool enableSpamActions + { + get + { + return this.enableSpamActionsField; + } + set + { + this.enableSpamActionsField = value; + } + } + + /// + public string spamLowAction + { + get + { + return this.spamLowActionField; + } + set + { + this.spamLowActionField = value; + } + } + + /// + public string spamLowArgs + { + get + { + return this.spamLowArgsField; + } + set + { + this.spamLowArgsField = value; + } + } + + /// + public string spamMedAction + { + get + { + return this.spamMedActionField; + } + set + { + this.spamMedActionField = value; + } + } + + /// + public string spamMedArgs + { + get + { + return this.spamMedArgsField; + } + set + { + this.spamMedArgsField = value; + } + } + + /// + public string spamHighAction + { + get + { + return this.spamHighActionField; + } + set + { + this.spamHighActionField = value; + } + } + + /// + public string spamHighArgs + { + get + { + return this.spamHighArgsField; + } + set + { + this.spamHighArgsField = value; + } + } + + /// + public bool smarterMailMode + { + get + { + return this.smarterMailModeField; + } + set + { + this.smarterMailModeField = value; + } + } + + /// + public string smarterMailURL + { + get + { + return this.smarterMailURLField; + } + set + { + this.smarterMailURLField = value; + } + } + + /// + public string authSmarterMailUserName + { + get + { + return this.authSmarterMailUserNameField; + } + set + { + this.authSmarterMailUserNameField = value; + } + } + + /// + public string authSmarterMailPassword + { + get + { + return this.authSmarterMailPasswordField; + } + set + { + this.authSmarterMailPasswordField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class IncomingGatewayResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private IncomingGatewayAttributes gatewayField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public IncomingGatewayAttributes gateway + { + get + { + return this.gatewayField; + } + set + { + this.gatewayField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SMTPBlockedSenderResult + { + + private string blockedSenderField; + + private string descriptionField; + + /// + public string BlockedSender + { + get + { + return this.blockedSenderField; + } + set + { + this.blockedSenderField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class SMTPBlockedSenderListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private SMTPBlockedSenderResult[] sMTPBlockedSendersField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public SMTPBlockedSenderResult[] SMTPBlockedSenders + { + get + { + return this.sMTPBlockedSendersField; + } + set + { + this.sMTPBlockedSendersField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class AddServerPortResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string newIDField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string NewID + { + get + { + return this.newIDField; + } + set + { + this.newIDField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class ServerPortResult + { + + private string idField; + + private string protocolField; + + private string encryptionField; + + private string certificatePathField; + + private string nameField; + + private int portField; + + private string descriptionField; + + /// + public string ID + { + get + { + return this.idField; + } + set + { + this.idField = value; + } + } + + /// + public string Protocol + { + get + { + return this.protocolField; + } + set + { + this.protocolField = value; + } + } + + /// + public string Encryption + { + get + { + return this.encryptionField; + } + set + { + this.encryptionField = value; + } + } + + /// + public string CertificatePath + { + get + { + return this.certificatePathField; + } + set + { + this.certificatePathField = value; + } + } + + /// + public string Name + { + get + { + return this.nameField; + } + set + { + this.nameField = value; + } + } + + /// + public int Port + { + get + { + return this.portField; + } + set + { + this.portField = value; + } + } + + /// + public string Description + { + get + { + return this.descriptionField; + } + set + { + this.descriptionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class ServerPortListResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private ServerPortResult[] portsField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public ServerPortResult[] Ports + { + get + { + return this.portsField; + } + set + { + this.portsField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.SerializableAttribute()] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + [System.Xml.Serialization.XmlTypeAttribute(Namespace = "http://tempuri.org/")] + public partial class EditionResult + { + + private bool resultField; + + private int resultCodeField; + + private string messageField; + + private string editionField; + + /// + public bool Result + { + get + { + return this.resultField; + } + set + { + this.resultField = value; + } + } + + /// + public int ResultCode + { + get + { + return this.resultCodeField; + } + set + { + this.resultCodeField = value; + } + } + + /// + public string Message + { + get + { + return this.messageField; + } + set + { + this.messageField = value; + } + } + + /// + public string Edition + { + get + { + return this.editionField; + } + set + { + this.editionField = value; + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void StartServicesCompletedEventHandler(object sender, StartServicesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class StartServicesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal StartServicesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void StopServicesCompletedEventHandler(object sender, StopServicesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class StopServicesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal StopServicesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RequestStatusCompletedEventHandler(object sender, RequestStatusCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RequestStatusCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RequestStatusCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public RequestStatusResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((RequestStatusResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetEditionCompletedEventHandler(object sender, GetEditionCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetEditionCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetEditionCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public EditionResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((EditionResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteServerPortCompletedEventHandler(object sender, DeleteServerPortCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteServerPortCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteServerPortCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListServerPortsCompletedEventHandler(object sender, ListServerPortsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListServerPortsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListServerPortsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public ServerPortListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((ServerPortListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddServerPortCompletedEventHandler(object sender, AddServerPortCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddServerPortCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddServerPortCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public AddServerPortResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((AddServerPortResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetSMTPBlockedSendersCompletedEventHandler(object sender, GetSMTPBlockedSendersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetSMTPBlockedSendersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetSMTPBlockedSendersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SMTPBlockedSenderListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SMTPBlockedSenderListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddDOSAbuseDetectionRuleCompletedEventHandler(object sender, AddDOSAbuseDetectionRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddDOSAbuseDetectionRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddDOSAbuseDetectionRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddHarvestingAbuseDetectionRuleCompletedEventHandler(object sender, AddHarvestingAbuseDetectionRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddHarvestingAbuseDetectionRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddHarvestingAbuseDetectionRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddIncomingGatewayCompletedEventHandler(object sender, AddIncomingGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddIncomingGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddIncomingGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetIncomingGatewayCompletedEventHandler(object sender, GetIncomingGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetIncomingGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetIncomingGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public IncomingGatewayResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((IncomingGatewayResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListIncomingGatewaysCompletedEventHandler(object sender, ListIncomingGatewaysCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListIncomingGatewaysCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListIncomingGatewaysCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public IncomingGatewayListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((IncomingGatewayListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateIncomingGatewayCompletedEventHandler(object sender, UpdateIncomingGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateIncomingGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateIncomingGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveIncomingGatewayCompletedEventHandler(object sender, RemoveIncomingGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveIncomingGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveIncomingGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventHandler(object sender, AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddInternalSpammerNotificationAbuseDetectionRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteAbuseDetectionRuleCompletedEventHandler(object sender, DeleteAbuseDetectionRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteAbuseDetectionRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteAbuseDetectionRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetDOSAbuseDetectionRulesCompletedEventHandler(object sender, GetDOSAbuseDetectionRulesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetDOSAbuseDetectionRulesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetDOSAbuseDetectionRulesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public DOSAbuseDetectionRulesListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((DOSAbuseDetectionRulesListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetHarvestingAbuseDetectionRulesCompletedEventHandler(object sender, GetHarvestingAbuseDetectionRulesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetHarvestingAbuseDetectionRulesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetHarvestingAbuseDetectionRulesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public HarvestingAbuseDetectionRulesListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((HarvestingAbuseDetectionRulesListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventHandler(object sender, GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetInternalSpammerNotificationAbuseDetectionRulesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public InternalSpammerNotificationAbuseDetectionRulesListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((InternalSpammerNotificationAbuseDetectionRulesListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSMTPBlockedSenderCompletedEventHandler(object sender, AddSMTPBlockedSenderCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSMTPBlockedSenderCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSMTPBlockedSenderCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteSpamAssassinServerCompletedEventHandler(object sender, DeleteSpamAssassinServerCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteSpamAssassinServerCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteSpamAssassinServerCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSpamAssassinServerCompletedEventHandler(object sender, AddSpamAssassinServerCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSpamAssassinServerCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSpamAssassinServerCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListSpamAssassinServersCompletedEventHandler(object sender, ListSpamAssassinServersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListSpamAssassinServersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListSpamAssassinServersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SpamAssassinServerListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SpamAssassinServerListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetRequestedSystemSettingsCompletedEventHandler(object sender, GetRequestedSystemSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetRequestedSystemSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetRequestedSystemSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public RequestSettingsResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((RequestSettingsResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetRequestedSystemSettingsCompletedEventHandler(object sender, SetRequestedSystemSettingsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetRequestedSystemSettingsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetRequestedSystemSettingsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetSpoolMessageCountCompletedEventHandler(object sender, GetSpoolMessageCountCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetSpoolMessageCountCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetSpoolMessageCountCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public MessageCountResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((MessageCountResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListGreylistingFiltersCompletedEventHandler(object sender, ListGreylistingFiltersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListGreylistingFiltersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListGreylistingFiltersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GreylistingFilterListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GreylistingFilterListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListPortsAssignedToIPCompletedEventHandler(object sender, ListPortsAssignedToIPCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListPortsAssignedToIPCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListPortsAssignedToIPCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public ServerPortListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((ServerPortListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemovePortFromIPCompletedEventHandler(object sender, RemovePortFromIPCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemovePortFromIPCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemovePortFromIPCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AssignPortToIPCompletedEventHandler(object sender, AssignPortToIPCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AssignPortToIPCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AssignPortToIPCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListGatewaysCompletedEventHandler(object sender, ListGatewaysCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListGatewaysCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListGatewaysCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GatewayListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GatewayListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetGatewayCompletedEventHandler(object sender, GetGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GatewayResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GatewayResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetGlobalTrustedSendersCompletedEventHandler(object sender, GetGlobalTrustedSendersCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetGlobalTrustedSendersCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetGlobalTrustedSendersCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public TrustedSenderListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((TrustedSenderListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddGlobalTrustedSenderCompletedEventHandler(object sender, AddGlobalTrustedSenderCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddGlobalTrustedSenderCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddGlobalTrustedSenderCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteGlobalTrustedSenderCompletedEventHandler(object sender, DeleteGlobalTrustedSenderCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteGlobalTrustedSenderCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteGlobalTrustedSenderCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteGreylistingFilterCompletedEventHandler(object sender, DeleteGreylistingFilterCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteGreylistingFilterCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteGreylistingFilterCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetWhitelistEntriesCompletedEventHandler(object sender, GetWhitelistEntriesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetWhitelistEntriesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetWhitelistEntriesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public WhitelistListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((WhitelistListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetBlacklistEntriesCompletedEventHandler(object sender, GetBlacklistEntriesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetBlacklistEntriesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetBlacklistEntriesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public BlacklistListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((BlacklistListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetBlacklistEntryCompletedEventHandler(object sender, SetBlacklistEntryCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetBlacklistEntryCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetBlacklistEntryCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetWhitelistEntryCompletedEventHandler(object sender, SetWhitelistEntryCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetWhitelistEntryCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetWhitelistEntryCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddGreylistingFilterCompletedEventHandler(object sender, AddGreylistingFilterCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddGreylistingFilterCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddGreylistingFilterCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSmtpAuthenticationBypassCompletedEventHandler(object sender, AddSmtpAuthenticationBypassCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSmtpAuthenticationBypassCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSmtpAuthenticationBypassCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteSmtpAuthenticationBypassCompletedEventHandler(object sender, DeleteSmtpAuthenticationBypassCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteSmtpAuthenticationBypassCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteSmtpAuthenticationBypassCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void GetSmtpAuthenticationBypassesCompletedEventHandler(object sender, GetSmtpAuthenticationBypassesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class GetSmtpAuthenticationBypassesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal GetSmtpAuthenticationBypassesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SMTPAuthBypassListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SMTPAuthBypassListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddGatewayCompletedEventHandler(object sender, AddGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSmarterMailGatewayCompletedEventHandler(object sender, AddSmarterMailGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSmarterMailGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSmarterMailGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveGatewayCompletedEventHandler(object sender, RemoveGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void UpdateGatewayCompletedEventHandler(object sender, UpdateGatewayCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class UpdateGatewayCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal UpdateGatewayCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListSystemAdminsCompletedEventHandler(object sender, ListSystemAdminsCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListSystemAdminsCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListSystemAdminsCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public SystemAdminListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((SystemAdminListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void SetSystemAdminPasswordCompletedEventHandler(object sender, SetSystemAdminPasswordCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class SetSystemAdminPasswordCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal SetSystemAdminPasswordCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteSystemAdminCompletedEventHandler(object sender, DeleteSystemAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteSystemAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteSystemAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddSystemAdminCompletedEventHandler(object sender, AddSystemAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddSystemAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddSystemAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddIPRestrictionToSystemAdminCompletedEventHandler(object sender, AddIPRestrictionToSystemAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddIPRestrictionToSystemAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddIPRestrictionToSystemAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void RemoveIPRestrictionFromSystemAdminCompletedEventHandler(object sender, RemoveIPRestrictionFromSystemAdminCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class RemoveIPRestrictionFromSystemAdminCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal RemoveIPRestrictionFromSystemAdminCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddHostnameCompletedEventHandler(object sender, AddHostnameCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddHostnameCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddHostnameCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteHostnameCompletedEventHandler(object sender, DeleteHostnameCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteHostnameCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteHostnameCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListHostnamesCompletedEventHandler(object sender, ListHostnamesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListHostnamesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListHostnamesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public HostnameListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((HostnameListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddFolderAutocleanRuleCompletedEventHandler(object sender, AddFolderAutocleanRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddFolderAutocleanRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddFolderAutocleanRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteFolderAutoCleanRuleCompletedEventHandler(object sender, DeleteFolderAutoCleanRuleCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteFolderAutoCleanRuleCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteFolderAutoCleanRuleCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListFolderAutoCleanRulesCompletedEventHandler(object sender, ListFolderAutoCleanRulesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListFolderAutoCleanRulesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListFolderAutoCleanRulesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public FolderAutoCleanRuleListResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((FolderAutoCleanRuleListResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void AddForwardingBlacklistEntryCompletedEventHandler(object sender, AddForwardingBlacklistEntryCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class AddForwardingBlacklistEntryCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal AddForwardingBlacklistEntryCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void DeleteForwardingBlacklistEntryCompletedEventHandler(object sender, DeleteForwardingBlacklistEntryCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class DeleteForwardingBlacklistEntryCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal DeleteForwardingBlacklistEntryCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public GenericResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((GenericResult)(this.results[0])); + } + } + } + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + public delegate void ListForwardingBlacklistEntriesCompletedEventHandler(object sender, ListForwardingBlacklistEntriesCompletedEventArgs e); + + /// + [System.CodeDom.Compiler.GeneratedCodeAttribute("wsdl", "4.0.30319.1")] + [System.Diagnostics.DebuggerStepThroughAttribute()] + [System.ComponentModel.DesignerCategoryAttribute("code")] + public partial class ListForwardingBlacklistEntriesCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs + { + + private object[] results; + + internal ListForwardingBlacklistEntriesCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : + base(exception, cancelled, userState) + { + this.results = results; + } + + /// + public ForwardingBlacklistRuleResult Result + { + get + { + this.RaiseExceptionIfNecessary(); + return ((ForwardingBlacklistRuleResult)(this.results[0])); + } + } + } + +} \ No newline at end of file diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/VersionInfo.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/VersionInfo.cs new file mode 100644 index 00000000..5a84a297 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/VersionInfo.cs @@ -0,0 +1,23 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.269 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: AssemblyCompany("Outercurve Foundation")] +[assembly: AssemblyCopyright("Copyright © 2012 Outercurve Foundation.")] +[assembly: AssemblyVersion("1.2.2.0")] +[assembly: AssemblyFileVersion("1.2.2.1")] +[assembly: AssemblyInformationalVersion("1.2.2")] + + diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/WebsitePanel.Providers.Mail.SmarterMail10.csproj b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/WebsitePanel.Providers.Mail.SmarterMail10.csproj new file mode 100644 index 00000000..df38d430 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail10/WebsitePanel.Providers.Mail.SmarterMail10.csproj @@ -0,0 +1,104 @@ + + + + Debug + x86 + 8.0.30703 + 2.0 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A} + Library + Properties + WebsitePanel.Providers.Mail + WebsitePanel.Providers.Mail.SmarterMail10 + v3.5 + 512 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + AnyCPU + true + full + false + ..\WebsitePanel.Server\bin\ + DEBUG;TRACE + prompt + 4 + 618 + + + x86 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + + + + + + + {684C932A-6C75-46AC-A327-F3689D89EB42} + WebsitePanel.Providers.Base + + + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7} + WebsitePanel.Server.Utils + + + + + \ No newline at end of file diff --git a/WebsitePanel/Sources/WebsitePanel.Server.sln b/WebsitePanel/Sources/WebsitePanel.Server.sln index d6a24e21..bbd2fc36 100644 --- a/WebsitePanel/Sources/WebsitePanel.Server.sln +++ b/WebsitePanel/Sources/WebsitePanel.Server.sln @@ -103,192 +103,478 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Server.WPIServ EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Server.WPIServiceContract", "WebsitePanel.Server.WPIServiceContract\WebsitePanel.Server.WPIServiceContract.csproj", "{736FA0F0-ECA3-416E-B299-85CC425FFF44}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Mail.SmarterMail10", "WebsitePanel.Providers.Mail.SmarterMail10\WebsitePanel.Providers.Mail.SmarterMail10.csproj", "{ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU + Release|Mixed Platforms = Release|Mixed Platforms + Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Debug|x86.ActiveCfg = Debug|Any CPU {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Release|Any CPU.ActiveCfg = Release|Any CPU {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Release|Any CPU.Build.0 = Release|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {38C6047C-E447-4CC2-891F-ABE54D4659F3}.Release|x86.ActiveCfg = Release|Any CPU {684C932A-6C75-46AC-A327-F3689D89EB42}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {684C932A-6C75-46AC-A327-F3689D89EB42}.Debug|Any CPU.Build.0 = Debug|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Debug|x86.ActiveCfg = Debug|Any CPU {684C932A-6C75-46AC-A327-F3689D89EB42}.Release|Any CPU.ActiveCfg = Release|Any CPU {684C932A-6C75-46AC-A327-F3689D89EB42}.Release|Any CPU.Build.0 = Release|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {684C932A-6C75-46AC-A327-F3689D89EB42}.Release|x86.ActiveCfg = Release|Any CPU {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Debug|x86.ActiveCfg = Debug|Any CPU {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Release|Any CPU.ActiveCfg = Release|Any CPU {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Release|Any CPU.Build.0 = Release|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {E91E52F3-9555-4D00-B577-2B1DBDD87CA7}.Release|x86.ActiveCfg = Release|Any CPU {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Debug|x86.ActiveCfg = Debug|Any CPU {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Release|Any CPU.ActiveCfg = Release|Any CPU {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Release|Any CPU.Build.0 = Release|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {990C4A2A-34A5-4BE0-9546-E10ABDFFFD0E}.Release|x86.ActiveCfg = Release|Any CPU {3744791D-C7B5-4818-8521-78EB5261CB34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3744791D-C7B5-4818-8521-78EB5261CB34}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Debug|x86.ActiveCfg = Debug|Any CPU {3744791D-C7B5-4818-8521-78EB5261CB34}.Release|Any CPU.ActiveCfg = Release|Any CPU {3744791D-C7B5-4818-8521-78EB5261CB34}.Release|Any CPU.Build.0 = Release|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {3744791D-C7B5-4818-8521-78EB5261CB34}.Release|x86.ActiveCfg = Release|Any CPU {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Debug|x86.ActiveCfg = Debug|Any CPU {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Release|Any CPU.ActiveCfg = Release|Any CPU {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Release|Any CPU.Build.0 = Release|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {1C26EBB3-E92E-48A5-B1FB-3AED9D5B9D74}.Release|x86.ActiveCfg = Release|Any CPU {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Debug|x86.ActiveCfg = Debug|Any CPU {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Release|Any CPU.ActiveCfg = Release|Any CPU {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Release|Any CPU.Build.0 = Release|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {899B3048-46BE-4C4D-9D41-0043C8B0D11E}.Release|x86.ActiveCfg = Release|Any CPU {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Debug|Any CPU.Build.0 = Debug|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Debug|x86.ActiveCfg = Debug|Any CPU {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Release|Any CPU.ActiveCfg = Release|Any CPU {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Release|Any CPU.Build.0 = Release|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {297C61C5-ECCE-49DE-B742-6BDA00B21B89}.Release|x86.ActiveCfg = Release|Any CPU {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Debug|x86.ActiveCfg = Debug|Any CPU {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Release|Any CPU.ActiveCfg = Release|Any CPU {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Release|Any CPU.Build.0 = Release|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {3148C2B2-8002-4FBE-9665-C65A83FA5F14}.Release|x86.ActiveCfg = Release|Any CPU {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Debug|x86.ActiveCfg = Debug|Any CPU {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Release|Any CPU.ActiveCfg = Release|Any CPU {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Release|Any CPU.Build.0 = Release|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {9BE0317D-E42E-4FF6-9A87-8C801F046EA1}.Release|x86.ActiveCfg = Release|Any CPU {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Debug|x86.ActiveCfg = Debug|Any CPU {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Release|Any CPU.ActiveCfg = Release|Any CPU {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Release|Any CPU.Build.0 = Release|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {54D5BDBC-42FC-41C3-902A-3583B9B496F4}.Release|x86.ActiveCfg = Release|Any CPU {5C98FE44-B6EF-4460-9530-E40D07846929}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5C98FE44-B6EF-4460-9530-E40D07846929}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Debug|x86.ActiveCfg = Debug|Any CPU {5C98FE44-B6EF-4460-9530-E40D07846929}.Release|Any CPU.ActiveCfg = Release|Any CPU {5C98FE44-B6EF-4460-9530-E40D07846929}.Release|Any CPU.Build.0 = Release|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {5C98FE44-B6EF-4460-9530-E40D07846929}.Release|x86.ActiveCfg = Release|Any CPU {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Debug|x86.ActiveCfg = Debug|Any CPU {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Release|Any CPU.ActiveCfg = Release|Any CPU {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Release|Any CPU.Build.0 = Release|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {3B31793D-7CA6-40C1-BC3B-EE85F414C626}.Release|x86.ActiveCfg = Release|Any CPU {B8965821-B64E-4A1B-9B72-E089B3D58861}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B8965821-B64E-4A1B-9B72-E089B3D58861}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Debug|x86.ActiveCfg = Debug|Any CPU {B8965821-B64E-4A1B-9B72-E089B3D58861}.Release|Any CPU.ActiveCfg = Release|Any CPU {B8965821-B64E-4A1B-9B72-E089B3D58861}.Release|Any CPU.Build.0 = Release|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {B8965821-B64E-4A1B-9B72-E089B3D58861}.Release|x86.ActiveCfg = Release|Any CPU {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Debug|x86.ActiveCfg = Debug|Any CPU {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Release|Any CPU.ActiveCfg = Release|Any CPU {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Release|Any CPU.Build.0 = Release|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D6EEEE68-CE10-44C2-84FD-3E37E565BE9C}.Release|x86.ActiveCfg = Release|Any CPU {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Debug|x86.ActiveCfg = Debug|Any CPU {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Release|Any CPU.ActiveCfg = Release|Any CPU {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Release|Any CPU.Build.0 = Release|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D640BF9A-C738-4C02-A8D9-0441D5AAAD74}.Release|x86.ActiveCfg = Release|Any CPU {51721D68-DBCB-4796-8455-004F1A43CB81}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {51721D68-DBCB-4796-8455-004F1A43CB81}.Debug|Any CPU.Build.0 = Debug|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Debug|x86.ActiveCfg = Debug|Any CPU {51721D68-DBCB-4796-8455-004F1A43CB81}.Release|Any CPU.ActiveCfg = Release|Any CPU {51721D68-DBCB-4796-8455-004F1A43CB81}.Release|Any CPU.Build.0 = Release|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {51721D68-DBCB-4796-8455-004F1A43CB81}.Release|x86.ActiveCfg = Release|Any CPU {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Debug|x86.ActiveCfg = Debug|Any CPU {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Release|Any CPU.ActiveCfg = Release|Any CPU {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Release|Any CPU.Build.0 = Release|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {2FA82B71-B32A-47DE-A17B-40DE08D0256D}.Release|x86.ActiveCfg = Release|Any CPU {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Debug|x86.ActiveCfg = Debug|Any CPU {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Release|Any CPU.ActiveCfg = Release|Any CPU {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Release|Any CPU.Build.0 = Release|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {7980CF32-62ED-4BA1-9CAE-8EE7BD164719}.Release|x86.ActiveCfg = Release|Any CPU {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Debug|x86.ActiveCfg = Debug|Any CPU {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Release|Any CPU.ActiveCfg = Release|Any CPU {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Release|Any CPU.Build.0 = Release|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {54EE4293-6CCB-4859-8B76-90205F7B35A1}.Release|x86.ActiveCfg = Release|Any CPU {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Debug|x86.ActiveCfg = Debug|Any CPU {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Release|Any CPU.ActiveCfg = Release|Any CPU {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Release|Any CPU.Build.0 = Release|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {FCD88E94-349D-4BB2-A726-6E47A4F01DC2}.Release|x86.ActiveCfg = Release|Any CPU {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Debug|x86.ActiveCfg = Debug|Any CPU {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Release|Any CPU.ActiveCfg = Release|Any CPU {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Release|Any CPU.Build.0 = Release|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {67EEA793-8621-4AD2-AE1D-4D975A8DA059}.Release|x86.ActiveCfg = Release|Any CPU {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Debug|x86.ActiveCfg = Debug|Any CPU {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Release|Any CPU.ActiveCfg = Release|Any CPU {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Release|Any CPU.Build.0 = Release|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {FE48854E-9332-4E37-A5F2-5DF9DDD740D5}.Release|x86.ActiveCfg = Release|Any CPU {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Debug|x86.ActiveCfg = Debug|Any CPU {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Release|Any CPU.ActiveCfg = Release|Any CPU {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Release|Any CPU.Build.0 = Release|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {622E452B-E1EF-4252-8039-A28C2EA25DC1}.Release|x86.ActiveCfg = Release|Any CPU {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Debug|x86.ActiveCfg = Debug|Any CPU {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Release|Any CPU.ActiveCfg = Release|Any CPU {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Release|Any CPU.Build.0 = Release|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {67B126AA-56E5-42F7-AC4F-AEE2A7D786F2}.Release|x86.ActiveCfg = Release|Any CPU {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Debug|x86.ActiveCfg = Debug|Any CPU {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Release|Any CPU.ActiveCfg = Release|Any CPU {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Release|Any CPU.Build.0 = Release|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {3ACCBEAE-5E1E-43E5-971C-223539832DD8}.Release|x86.ActiveCfg = Release|Any CPU {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Debug|x86.ActiveCfg = Debug|Any CPU {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Release|Any CPU.ActiveCfg = Release|Any CPU {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Release|Any CPU.Build.0 = Release|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {41FEC24A-67A2-4BF4-8889-1D5CD0A2B43D}.Release|x86.ActiveCfg = Release|Any CPU {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Debug|x86.ActiveCfg = Debug|Any CPU {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Release|Any CPU.ActiveCfg = Release|Any CPU {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Release|Any CPU.Build.0 = Release|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {A2C62A7C-C1F0-41F1-A514-7BD39B70C3BB}.Release|x86.ActiveCfg = Release|Any CPU {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Debug|x86.ActiveCfg = Debug|Any CPU {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Release|Any CPU.ActiveCfg = Release|Any CPU {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Release|Any CPU.Build.0 = Release|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {F04CE8DC-6DE1-411A-B912-73ED7EA662D1}.Release|x86.ActiveCfg = Release|Any CPU {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Debug|x86.ActiveCfg = Debug|Any CPU {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Release|Any CPU.ActiveCfg = Release|Any CPU {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Release|Any CPU.Build.0 = Release|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {1B9DCE85-C664-49FC-B6E1-86C63CAB88D1}.Release|x86.ActiveCfg = Release|Any CPU {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Debug|x86.ActiveCfg = Debug|Any CPU {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Release|Any CPU.ActiveCfg = Release|Any CPU {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Release|Any CPU.Build.0 = Release|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {BED2F43F-2DD8-45CF-AD7C-86799897C575}.Release|x86.ActiveCfg = Release|Any CPU {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Debug|x86.ActiveCfg = Debug|Any CPU {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Release|Any CPU.ActiveCfg = Release|Any CPU {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Release|Any CPU.Build.0 = Release|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {A28BD694-C308-449F-8FD2-F08F3D54ABA0}.Release|x86.ActiveCfg = Release|Any CPU {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Debug|x86.ActiveCfg = Debug|Any CPU {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Release|Any CPU.ActiveCfg = Release|Any CPU {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Release|Any CPU.Build.0 = Release|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {7D6D38E3-B445-480F-9CD5-BCDFB22D13BB}.Release|x86.ActiveCfg = Release|Any CPU {A06DE5E4-4331-47E1-8F46-7B846146B559}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A06DE5E4-4331-47E1-8F46-7B846146B559}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Debug|x86.ActiveCfg = Debug|Any CPU {A06DE5E4-4331-47E1-8F46-7B846146B559}.Release|Any CPU.ActiveCfg = Release|Any CPU {A06DE5E4-4331-47E1-8F46-7B846146B559}.Release|Any CPU.Build.0 = Release|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {A06DE5E4-4331-47E1-8F46-7B846146B559}.Release|x86.ActiveCfg = Release|Any CPU {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Debug|x86.ActiveCfg = Debug|Any CPU {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Release|Any CPU.ActiveCfg = Release|Any CPU {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Release|Any CPU.Build.0 = Release|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {2B4DC551-AF11-4F85-99DB-3F85917299A4}.Release|x86.ActiveCfg = Release|Any CPU {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Debug|x86.ActiveCfg = Debug|Any CPU {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Release|Any CPU.ActiveCfg = Release|Any CPU {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Release|Any CPU.Build.0 = Release|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D4A435B4-3AB1-4DCB-AF66-68C3ABA759C2}.Release|x86.ActiveCfg = Release|Any CPU {431A94E2-28A3-43D9-8529-31F859C323B6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {431A94E2-28A3-43D9-8529-31F859C323B6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Debug|x86.ActiveCfg = Debug|Any CPU {431A94E2-28A3-43D9-8529-31F859C323B6}.Release|Any CPU.ActiveCfg = Release|Any CPU {431A94E2-28A3-43D9-8529-31F859C323B6}.Release|Any CPU.Build.0 = Release|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {431A94E2-28A3-43D9-8529-31F859C323B6}.Release|x86.ActiveCfg = Release|Any CPU {88E9734F-2066-4674-AA5B-F1A772436F04}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {88E9734F-2066-4674-AA5B-F1A772436F04}.Debug|Any CPU.Build.0 = Debug|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Debug|x86.ActiveCfg = Debug|Any CPU {88E9734F-2066-4674-AA5B-F1A772436F04}.Release|Any CPU.ActiveCfg = Release|Any CPU {88E9734F-2066-4674-AA5B-F1A772436F04}.Release|Any CPU.Build.0 = Release|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {88E9734F-2066-4674-AA5B-F1A772436F04}.Release|x86.ActiveCfg = Release|Any CPU {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Debug|x86.ActiveCfg = Debug|Any CPU {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Release|Any CPU.ActiveCfg = Release|Any CPU {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Release|Any CPU.Build.0 = Release|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {7105A714-FF61-46B2-A16E-F4CBAD71BF02}.Release|x86.ActiveCfg = Release|Any CPU {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Debug|x86.ActiveCfg = Debug|Any CPU {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Release|Any CPU.ActiveCfg = Release|Any CPU {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Release|Any CPU.Build.0 = Release|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {8F644D50-D602-4AD3-8EB0-CA3C3676B18D}.Release|x86.ActiveCfg = Release|Any CPU {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Debug|x86.ActiveCfg = Debug|Any CPU {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Release|Any CPU.ActiveCfg = Release|Any CPU {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Release|Any CPU.Build.0 = Release|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {FB773A2C-1CD3-4D76-9C4F-B6B7EB9E479C}.Release|x86.ActiveCfg = Release|Any CPU {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|x86.ActiveCfg = Debug|Any CPU {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Release|Any CPU.ActiveCfg = Release|Any CPU {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Release|Any CPU.Build.0 = Release|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Release|x86.ActiveCfg = Release|Any CPU {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Debug|x86.ActiveCfg = Debug|Any CPU {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Any CPU.ActiveCfg = Release|Any CPU {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Any CPU.Build.0 = Release|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|x86.ActiveCfg = Release|Any CPU {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Debug|x86.ActiveCfg = Debug|Any CPU {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Release|Any CPU.ActiveCfg = Release|Any CPU {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Release|Any CPU.Build.0 = Release|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {DD9E57D5-797F-4420-AF1A-23CEA2F310E0}.Release|x86.ActiveCfg = Release|Any CPU {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Debug|Any CPU.Build.0 = Debug|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Debug|x86.ActiveCfg = Debug|Any CPU {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Release|Any CPU.ActiveCfg = Release|Any CPU {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Release|Any CPU.Build.0 = Release|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {736FA0F0-ECA3-416E-B299-85CC425FFF44}.Release|x86.ActiveCfg = Release|Any CPU + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Debug|Any CPU.ActiveCfg = Debug|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Debug|Mixed Platforms.ActiveCfg = Debug|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Debug|Mixed Platforms.Build.0 = Debug|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Debug|x86.ActiveCfg = Debug|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Debug|x86.Build.0 = Debug|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Release|Any CPU.ActiveCfg = Release|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Release|Mixed Platforms.ActiveCfg = Release|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Release|Mixed Platforms.Build.0 = Release|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Release|x86.ActiveCfg = Release|x86 + {ADEAADF8-62E6-4AA9-9E0D-A8E552A2A85A}.Release|x86.Build.0 = Release|x86 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE