diff --git a/WebsitePanel/Database/install_db.sql b/WebsitePanel/Database/install_db.sql index 6f7892d9..4f337c2e 100644 --- a/WebsitePanel/Database/install_db.sql +++ b/WebsitePanel/Database/install_db.sql @@ -17363,6 +17363,8 @@ INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName] GO INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (64, 4, N'SmarterMail', N'SmarterMail 7.x', N'WebsitePanel.Providers.Mail.SmarterMail7, WebsitePanel.Providers.Mail.SmarterMail7', N'SmarterMail60', NULL) GO +INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (65, 4, N'SmarterMail', N'SmarterMail 9.x', N'WebsitePanel.Providers.Mail.SmarterMail9, WebsitePanel.Providers.Mail.SmarterMail9', N'SmarterMail60', NULL) +GO INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (100, 1, N'Windows2008', N'Windows Server 2008', N'WebsitePanel.Providers.OS.Windows2008, WebsitePanel.Providers.OS.Windows2008', N'Windows2008', NULL) GO INSERT [dbo].[Providers] ([ProviderID], [GroupID], [ProviderName], [DisplayName], [ProviderType], [EditorControl], [DisableAutoDiscovery]) VALUES (101, 2, N'IIS70', N'Internet Information Services 7.0', N'WebsitePanel.Providers.Web.IIs70, WebsitePanel.Providers.Web.IIs70', N'IIS70', NULL) @@ -30707,6 +30709,16 @@ INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [Property GO INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (64, N'ServiceUrl', N'http://localhost:9998/services/') GO +INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (65, N'AdminPassword', N'') +GO +INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (65, N'AdminUsername', N'admin') +GO +INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (65, N'DomainsPath', N'%SYSTEMDRIVE%\SmarterMail') +GO +INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (65, N'ServerIPAddress', N'127.0.0.1;127.0.0.1') +GO +INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (65, N'ServiceUrl', N'http://localhost:9998/services/') +GO INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (100, N'UsersHome', N'%SYSTEMDRIVE%\HostingSpaces') GO INSERT [dbo].[ServiceDefaultProperties] ([ProviderID], [PropertyName], [PropertyValue]) VALUES (101, N'AspNet11Pool', N'ASP.NET 1.1') diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/Extensions.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/Extensions.cs new file mode 100644 index 00000000..94be410e --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/Extensions.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace WebsitePanel.Providers.Mail.SM9.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", + // ZMIANA dodanie encoding + "textencoding=65001" + }; + } + } +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9.cs new file mode 100644 index 00000000..7fbef6b9 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9.cs @@ -0,0 +1,2174 @@ +// Copyright (c) 2010, SMB SAAS Systems Inc. +// 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 SMB SAAS Systems Inc. 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.SM9; +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.SM9.Extensions; + +namespace WebsitePanel.Providers.Mail +{ + public class SmarterMail9 : 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)); + + 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)) + { + string[] split = productVersion.Split(new char[] { '.' }); + return split[0].Equals("9"); + } + } + + //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)) + { + string[] split = productVersion.Split(new[] { '.' }); + return split[0].Equals("9"); + } + + return false; + + } + } + + + + +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9Proxies.cs b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9Proxies.cs new file mode 100644 index 00000000..c29f63f4 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/SmarterMail9Proxies.cs @@ -0,0 +1,12114 @@ +//------------------------------------------------------------------------------ +// +// 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.SM9 { + 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; + + /// + 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; + + /// + [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)); + } + } + + /// + 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")] + [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 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 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 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 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/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/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 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 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")] + 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 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 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 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 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 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/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/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 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 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 RequestStatusOperationCompleted; + + private System.Threading.SendOrPostCallback GetEditionOperationCompleted; + + private System.Threading.SendOrPostCallback GetRequestedSystemSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback SetRequestedSystemSettingsOperationCompleted; + + private System.Threading.SendOrPostCallback GetSpoolMessageCountOperationCompleted; + + private System.Threading.SendOrPostCallback ListGatewaysOperationCompleted; + + private System.Threading.SendOrPostCallback GetGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback AddGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback AddSmarterMailGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback RemoveGatewayOperationCompleted; + + private System.Threading.SendOrPostCallback UpdateGatewayOperationCompleted; + + /// + public svcServerAdmin() { + this.Url = "http://127.0.0.1:9998/Services/svcServerAdmin.asmx"; + } + + /// + public event RequestStatusCompletedEventHandler RequestStatusCompleted; + + /// + public event GetEditionCompletedEventHandler GetEditionCompleted; + + /// + public event GetRequestedSystemSettingsCompletedEventHandler GetRequestedSystemSettingsCompleted; + + /// + public event SetRequestedSystemSettingsCompletedEventHandler SetRequestedSystemSettingsCompleted; + + /// + public event GetSpoolMessageCountCompletedEventHandler GetSpoolMessageCountCompleted; + + /// + public event ListGatewaysCompletedEventHandler ListGatewaysCompleted; + + /// + public event GetGatewayCompletedEventHandler GetGatewayCompleted; + + /// + public event AddGatewayCompletedEventHandler AddGatewayCompleted; + + /// + public event AddSmarterMailGatewayCompletedEventHandler AddSmarterMailGatewayCompleted; + + /// + public event RemoveGatewayCompletedEventHandler RemoveGatewayCompleted; + + /// + public event UpdateGatewayCompletedEventHandler UpdateGatewayCompleted; + + /// + [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/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/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/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)); + } + } + + /// + 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 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 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 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 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 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 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 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])); + } + } + } +} diff --git a/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.csproj b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.csproj new file mode 100644 index 00000000..5c51f3c0 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.csproj @@ -0,0 +1,71 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {FB97E984-2463-44EB-B8BE-14AA41D0365E} + Library + Properties + WebsitePanel.Providers.Mail + WebsitePanel.Providers.Mail.SmarterMail9 + v4.0 + 512 + + + + true + full + false + ..\WebsitePanel.Server\bin\ + DEBUG;TRACE + prompt + 4 + 618 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + 618 + + + + + + + + + + VersionInfo.cs + + + + + + + + {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.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.sln b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.sln new file mode 100644 index 00000000..b8deecc2 --- /dev/null +++ b/WebsitePanel/Sources/WebsitePanel.Providers.Mail.SmarterMail9/WebsitePanel.Providers.Mail.SmarterMail9.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Mail.SmarterMail9", "WebsitePanel.Providers.Mail.SmarterMail9.csproj", "{FB97E984-2463-44EB-B8BE-14AA41D0365E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {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}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/WebsitePanel/Sources/WebsitePanel.Server.sln b/WebsitePanel/Sources/WebsitePanel.Server.sln index 5cff53d2..2a54b5f5 100644 --- a/WebsitePanel/Sources/WebsitePanel.Server.sln +++ b/WebsitePanel/Sources/WebsitePanel.Server.sln @@ -101,6 +101,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Mail EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.VirtualizationForPC.HyperVForPC", "WebsitePanel.Providers.Virtualization.HyperVForPC\WebsitePanel.Providers.VirtualizationForPC.HyperVForPC.csproj", "{64BEEB10-7F9F-4860-B2FF-84CDA02766B3}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebsitePanel.Providers.Mail.SmarterMail9", "WebsitePanel.Providers.Mail.SmarterMail9\WebsitePanel.Providers.Mail.SmarterMail9.csproj", "{FB97E984-2463-44EB-B8BE-14AA41D0365E}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -279,6 +281,10 @@ Global {64BEEB10-7F9F-4860-B2FF-84CDA02766B3}.Debug|Any CPU.Build.0 = 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 + {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}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FB97E984-2463-44EB-B8BE-14AA41D0365E}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE