IXmppService.cs

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Xml;
using EDaler;
using EDaler.Events;
using EDaler.Uris;
using NeuroAccessMaui.Services.Push;
using NeuroAccessMaui.Services.Wallet;
using NeuroAccessMaui.UI.Pages.Onboarding;
using NeuroFeatures;
using NeuroFeatures.EventArguments;
using NeuroFeatures.Events;
using Waher.Content;
using Waher.Events;
using Waher.Networking;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP;
using Waher.Networking.XMPP.Contracts;
using Waher.Networking.XMPP.Contracts.EventArguments;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.Events;
using Waher.Networking.XMPP.HttpFileUpload;
using Waher.Networking.XMPP.PEP.Events;
using Waher.Networking.XMPP.Provisioning;
using Waher.Networking.XMPP.Provisioning.Events;
using Waher.Networking.XMPP.Provisioning.SearchOperators;
using Waher.Networking.XMPP.PubSub;
using Waher.Networking.XMPP.PubSub.Events;
using Waher.Networking.XMPP.Push;
using Waher.Networking.XMPP.Sensor;
using Waher.Networking.XMPP.ServiceDiscovery;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Temporary;
using Waher.Things;
using Waher.Things.SensorData;
 
namespace NeuroAccessMaui.Services.Xmpp
{
    [DefaultImplementation(typeof(XmppService))]
    public interface IXmppService : ILoadableService
    {
        #region Lifecycle
 
        Task<bool> WaitForConnectedState(TimeSpan timeout);
 
        Task UnloadFast();
 
        event EventHandlerAsync<XmppState> ConnectionStateChanged;
 
        #endregion
 
        #region State
 
        bool IsOnline { get; }
 
        XmppState State { get; }
 
        string BareJid { get; }
 
        string? LatestError { get; }
 
        string? LatestConnectionError { get; }
 
        #endregion
 
        #region Connections
 
        Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnect(string domain, bool isIpAddress, string hostName, int portNumber,
                string languageCode, Assembly appAssembly, Func<XmppClient, Task> connectedFunc);
 
        Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndCreateAccount(string domain, bool isIpAddress, string hostName,
            int portNumber, string userName, string password, string languageCode, string ApiKey, string ApiSecret,
            Assembly appAssembly, Func<XmppClient, Task> connectedFunc);
 
        Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndConnectToAccount(string domain, bool isIpAddress, string hostName,
            int portNumber, string userName, string password, string passwordMethod, string languageCode, Assembly appAssembly,
            Func<XmppClient, Task> connectedFunc);
 
        #endregion
 
        #region Password
 
        Task<bool> ChangePassword(string NewPassword);
 
 
        Task<bool> TryGenerateAndChangePassword();
 
        #endregion
 
        #region Components & Services
 
        Task<ServiceDiscoveryEventArgs> SendServiceDiscoveryRequest(string FullJid);
 
        Task<bool> DiscoverServices(XmppClient? Client = null);
 
        #endregion
 
        #region Transfer
 
        Task AddTransferCode(string Code);
 
        #endregion
 
        #region IQ Stanzas (Information Query)
 
        Task<XmlElement> IqSetAsync(string To, string Xml);
 
        #endregion
 
        #region Messages
 
        public void SendMessage(QoSLevel QoS, MessageType Type, string Id, string To, string CustomXml,
            string Body, string Subject, string Language, string ThreadId, string ParentThreadId,
            EventHandlerAsync<DeliveryEventArgs>? DeliveryCallback, object? State);
 
        #endregion
 
        #region Presence
 
        event EventHandlerAsync<PresenceEventArgs> OnPresence;
 
        event EventHandlerAsync<PresenceEventArgs> OnPresenceSubscribe;
 
        event EventHandlerAsync<PresenceEventArgs> OnPresenceUnsubscribed;
 
        void RequestPresenceSubscription(string BareJid);
 
        void RequestPresenceSubscription(string BareJid, string CustomXml);
 
        void RequestPresenceUnsubscription(string BareJid);
 
        void RequestRevokePresenceSubscription(string BareJid);
 
        #endregion
 
        #region Roster
 
        RosterItem[] Roster { get; }
 
        RosterItem? GetRosterItem(string BareJid);
 
        void AddRosterItem(RosterItem Item);
 
        void RemoveRosterItem(string BareJid);
 
        event EventHandlerAsync<RosterItem> OnRosterItemAdded;
 
        event EventHandlerAsync<RosterItem> OnRosterItemUpdated;
 
        event EventHandlerAsync<RosterItem> OnRosterItemRemoved;
 
        #endregion
 
        #region Push Notification
 
        bool SupportsPushNotification { get; }
 
        Task<bool> NewPushNotificationToken(TokenInformation TokenInformation);
 
        Task ReportNewPushNotificationToken(string Token, PushMessagingService Service, ClientType ClientType);
 
        Task ClearPushNotificationRules();
 
        Task AddPushNotificationRule(MessageType MessageType, string LocalName, string Namespace, string Channel,
            string MessageVariable, string PatternMatchingScript, string ContentScript);
 
        #endregion
 
        #region Tokens
 
        Task<string?> GetApiToken(int Seconds);
 
        Task<object> PostToProtectedApi(string LocalResource, object Data, params KeyValuePair<string, string>[] Headers);
 
        #endregion
 
        #region HTTP File Upload
 
        bool FileUploadIsSupported { get; }
 
        Task<HttpFileUploadEventArgs> RequestUploadSlotAsync(string FileName, string ContentType, long ContentSize);
 
        #endregion
 
        #region Personal Eventing Protocol (PEP)
 
        void RegisterPepHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler);
 
        bool UnregisterPepHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler);
 
        #endregion
 
        #region Thing Registries & Discovery
 
        string RegistryServiceJid { get; }
 
        bool IsIoTDiscoClaimURI(string DiscoUri);
 
        bool IsIoTDiscoSearchURI(string DiscoUri);
 
        bool IsIoTDiscoDirectURI(string DiscoUri);
 
        bool TryDecodeIoTDiscoClaimURI(string DiscoUri, [NotNullWhen(true)] out MetaDataTag[]? Tags);
 
        bool TryDecodeIoTDiscoSearchURI(string DiscoUri, [NotNullWhen(true)] out SearchOperator[]? Operators, out string? RegistryJid);
 
        bool TryDecodeIoTDiscoDirectURI(string DiscoUri, [NotNullWhen(true)] out string? Jid, out string? SourceId, out string? NodeId,
            out string? PartitionId, [NotNullWhen(true)] out MetaDataTag[]? Tags);
 
        Task<NodeResultEventArgs> ClaimThing(string DiscoUri, bool MakePublic);
 
        Task<bool> Disown(string RegistryJid, string ThingJid, string SourceId, string Partition, string NodeId);
 
        Task<(SearchResultThing[], string?, bool)> Search(int Offset, int MaxCount, string DiscoUri);
 
        Task<(SearchResultThing[], bool)> Search(int Offset, int MaxCount, string? RegistryJid, params SearchOperator[] Operators);
 
        Task<(SearchResultThing[], string?)> SearchAll(string DiscoUri);
 
        Task<SearchResultThing[]> SearchAll(string RegistryJid, params SearchOperator[] Operators);
 
        #endregion
 
        #region Legal Identities
 
        Task GenerateNewKeys();
 
        Task<IdApplicationAttributesEventArgs> GetIdApplicationAttributes();
 
        Task<LegalIdentity> AddLegalIdentity(RegisterIdentityModel Model, bool GenerateNewKeys, params LegalIdentityAttachment[] Attachments);
 
        Task<LegalIdentity> AddLegalIdentity(Property[] Props, bool GenerateNewKeys, params LegalIdentityAttachment[] Attachments);
 
        Task<LegalIdentity[]> GetLegalIdentities(XmppClient? client = null);
 
        Task<LegalIdentity> GetLegalIdentity(CaseInsensitiveString legalIdentityId);
 
        Task<bool> IsContact(CaseInsensitiveString legalIdentityId);
 
        Task<bool> HasPrivateKey(CaseInsensitiveString legalIdentityId);
 
        Task<LegalIdentity> ObsoleteLegalIdentity(CaseInsensitiveString legalIdentityId);
 
        Task<LegalIdentity> CompromiseLegalIdentity(CaseInsensitiveString legalIdentityId);
 
        Task PetitionIdentity(CaseInsensitiveString LegalId, string PetitionId, string Purpose);
 
        Task SendPetitionIdentityResponse(CaseInsensitiveString LegalId, string PetitionId, string RequestorFullJid, bool Response);
 
        event EventHandlerAsync<LegalIdentityEventArgs> LegalIdentityChanged;
 
        event EventHandlerAsync<LegalIdentityEventArgs> IdentityApplicationChanged;
 
        event EventHandlerAsync<LegalIdentityPetitionEventArgs> PetitionForIdentityReceived;
 
        event EventHandlerAsync<LegalIdentityPetitionResponseEventArgs> PetitionedIdentityResponseReceived;
 
        Task ExportSigningKeys(XmlWriter Output);
 
        Task<bool> ImportSigningKeys(XmlElement Xml);
 
        Task<IdentityStatus> ValidateIdentity(LegalIdentity Identity);
 
        #endregion
 
        #region Smart Contracts
 
        ContractsClient ContractsClient { get; }
 
        Task<Contract> GetContract(CaseInsensitiveString ContractId);
 
        Task<string[]> GetCreatedContractReferences();
 
        Task<string[]> GetSignedContractReferences();
 
        Task<Contract> SignContract(Contract Contract, string Role, bool Transferable);
 
        Task<Contract> ObsoleteContract(CaseInsensitiveString ContractId);
 
        Task<Contract> CreateContract(
            CaseInsensitiveString TemplateId,
            Part[] Parts,
            Parameter[] Parameters,
            ContractVisibility Visibility,
            ContractParts PartsMode,
            Duration Duration,
            Duration ArchiveRequired,
            Duration ArchiveOptional,
            DateTime? SignAfter,
            DateTime? SignBefore,
            bool CanActAsTemplate);
 
        Task<Contract> DeleteContract(CaseInsensitiveString ContractId);
 
        Task PetitionContract(CaseInsensitiveString ContractId, string PetitionId, string Purpose);
 
        Task SendPetitionContractResponse(CaseInsensitiveString ContractId, string PetitionId, string RequestorFullJid, bool Response);
 
        event EventHandlerAsync<ContractProposalEventArgs> ContractProposalReceived;
 
        event EventHandlerAsync<ContractReferenceEventArgs> ContractUpdated;
 
        event EventHandlerAsync<ContractSignedEventArgs> ContractSigned;
 
        event EventHandlerAsync<ContractPetitionEventArgs> PetitionForContractReceived;
 
        event EventHandlerAsync<ContractPetitionResponseEventArgs> PetitionedContractResponseReceived;
 
        DateTime GetTimeOfLastContractEvent(CaseInsensitiveString ContractId);
 
        Task SendContractProposal(Contract Contract, string Role, string To, string Message);
 
        #endregion
 
        #region Attachments
 
        Task<KeyValuePair<string, TemporaryFile>> GetAttachment(string Url, SignWith SignWith, TimeSpan Timeout);
 
        #endregion
 
        #region Peer Review
 
        Task PetitionPeerReviewId(CaseInsensitiveString LegalId, LegalIdentity Identity, string PetitionId, string Purpose);
 
        Task<LegalIdentity> AddPeerReviewIdAttachment(LegalIdentity Identity, LegalIdentity ReviewerLegalIdentity, byte[] PeerSignature);
 
        event EventHandlerAsync<SignaturePetitionEventArgs> PetitionForPeerReviewIdReceived;
 
        event EventHandlerAsync<SignaturePetitionResponseEventArgs> PetitionedPeerReviewIdResponseReceived;
 
        Task<ServiceProviderWithLegalId[]> GetServiceProvidersForPeerReviewAsync();
 
        Task SelectPeerReviewService(string ServiceId, string ServiceProvider);
 
        #endregion
 
        #region Signatures
 
        Task<byte[]> Sign(byte[] data, SignWith signWith);
 
        bool? ValidateSignature(LegalIdentity legalIdentity, byte[] data, byte[] signature);
 
        Task SendPetitionSignatureResponse(CaseInsensitiveString LegalId, byte[] Content, byte[] Signature, string PetitionId, string RequestorFullJid, bool Response);
 
        event EventHandlerAsync<SignaturePetitionEventArgs> PetitionForSignatureReceived;
 
        event EventHandlerAsync<SignaturePetitionResponseEventArgs> SignaturePetitionResponseReceived;
 
        #endregion
 
        #region Provisioning
 
        string ProvisioningServiceJid { get; }
 
        void IsFriendResponse(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool IsFriend,
            RuleRange Range, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanControlResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanControl,
            string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanControlResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanControlResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanControlResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void CanControlResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void CanControlResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void CanReadResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanRead,
            FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanReadResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanRead,
            FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanReadResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanRead,
            FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void CanReadResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void CanReadResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void CanReadResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,
            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,
            object? State);
 
        void DeleteDeviceRules(string ServiceJID, string DeviceJID, string NodeId, string SourceId, string Partition,
            EventHandlerAsync<IqResultEventArgs> Callback, object? State);
 
        void GetCertificate(string Token, EventHandlerAsync<CertificateEventArgs> Callback, object? State);
 
        #endregion
 
        #region IoT
 
        Task<(SearchResultThing[], bool)> GetMyDevices(int Offset, int MaxCount);
 
        Task<SearchResultThing[]> GetAllMyDevices();
 
        void GetControlForm(string To, string Language, EventHandlerAsync<DataFormEventArgs> Callback, object? State,
            params ThingReference[] Nodes);
 
        Task<SensorDataClientRequest> RequestSensorReadout(string Destination, FieldType Types);
 
        Task<SensorDataClientRequest> RequestSensorReadout(string Destination, ThingReference[] Nodes, FieldType Types);
 
        #endregion
 
        #region e-Daler
 
        bool TryParseEDalerUri(string Uri, out EDalerUri Parsed, out string Reason);
 
        Task<string> TryDecryptMessage(byte[] EncryptedMessage, byte[] PublicKey, Guid TransactionId, string RemoteEndpoint,bool LocalIsRecipient = false);
 
        Task<EDaler.Transaction> SendEDalerUri(string Uri);
 
        event EventHandlerAsync<BalanceEventArgs> EDalerBalanceUpdated;
 
        Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount);
 
        Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount, DateTime From);
 
        Task<Balance> GetEDalerBalance();
 
        Task<(decimal, string, PendingPayment[])> GetPendingEDalerPayments();
 
        Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays);
 
        Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string Message);
 
        Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays);
 
        Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string PrivateMessage);
 
        string CreateIncompleteEDalerPayMeUri(string BareJid, decimal? Amount, decimal? AmountExtra, string Currency, string Message);
 
        string CreateIncompleteEDalerPayMeUri(LegalIdentity To, decimal? Amount, decimal? AmountExtra, string Currency, string PrivateMessage);
 
        Balance? LastEDalerBalance { get; }
 
        DateTime LastEDalerEvent { get; }
 
        Task<IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync();
 
        Task<OptionsTransaction> InitiateBuyEDalerGetOptions(string ServiceId, string ServiceProvider);
 
        void BuyEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options);
 
        void BuyEDalerGetOptionsFailed(string TransactionId, string Message);
 
        Task<PaymentTransaction> InitiateBuyEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency);
 
        Task<OptionsTransaction> InitiateSellEDalerGetOptions(string ServiceId, string ServiceProvider);
 
        void SellEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options);
 
        void SellEDalerGetOptionsFailed(string TransactionId, string Message);
 
        void BuyEDalerCompleted(string TransactionId, decimal Amount, string Currency);
 
        void BuyEDalerFailed(string TransactionId, string Message);
 
        Task<ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync();
 
        Task<PaymentTransaction> InitiateSellEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency);
 
        void SellEDalerCompleted(string TransactionId, decimal Amount, string Currency);
 
        void SellEDalerFailed(string TransactionId, string Message);
 
        #endregion
 
        #region Neuro-Features
 
        event EventHandlerAsync<NeuroFeatures.EventArguments.TokenEventArgs> NeuroFeatureRemoved;
 
        event EventHandlerAsync<NeuroFeatures.EventArguments.TokenEventArgs> NeuroFeatureAdded;
 
        event EventHandlerAsync<VariablesUpdatedEventArgs> NeuroFeatureVariablesUpdated;
 
        event EventHandlerAsync<NewStateEventArgs>? NeuroFeatureStateUpdated;
 
        DateTime LastNeuroFeatureEvent { get; }
 
        Task<TokensEventArgs> GetNeuroFeatures();
 
        Task<TokensEventArgs> GetNeuroFeatures(int Offset, int MaxCount);
 
        Task<string[]> GetNeuroFeatureReferences();
 
        Task<string[]> GetNeuroFeatureReferences(int Offset, int MaxCount);
 
        Task<TokenTotalsEventArgs> GetNeuroFeatureTotals();
 
        Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId);
 
        Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId, int Offset, int MaxCount);
 
        Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId);
 
        Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId, int Offset, int MaxCount);
 
        Task<Token> GetNeuroFeature(string TokenId);
 
        Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId);
 
        Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId, int Offset, int MaxCount);
 
        Task AddNeuroFeatureTextNote(string TokenId, string TextNote);
 
        Task AddNeuroFeatureTextNote(string TokenId, string TextNote, bool Personal);
 
        Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote);
 
        Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote, bool Personal);
 
        Task<CreationAttributesEventArgs> GetNeuroFeatureCreationAttributes();
 
        Task<string> GenerateNeuroFeatureStateDiagramReport(string TokenId);
 
        Task<VerticalStackLayout> GenerateNeuroFeatureStateDiagramReportMaui(string TokenId);
 
        Task<string> GenerateNeuroFeatureProfilingReport(string TokenId);
 
        Task<VerticalStackLayout> GenerateNeuroFeatureProfilingReportMaui(string TokenId);
 
        Task<string> GenerateNeuroFeaturePresentReport(string TokenId);
 
        Task<VerticalStackLayout> GenerateNeuroFeaturePresentReportMaui(string TokenId);
 
        Task<string> GenerateNeuroFeatureHistoryReport(string TokenId);
 
        Task<VerticalStackLayout> GenerateNeuroFeatureHistoryReportMaui(string TokenId);
 
        Task<CurrentStateEventArgs> GetNeuroFeatureCurrentState(string TokenId);
 
        #endregion
 
        #region Private XML
 
        Task SavePrivateXml(string Xml);
 
        Task SavePrivateXml(XmlElement Xml);
 
        Task<XmlElement?> LoadPrivateXml(string LocalName, string Namespace);
 
        Task DeletePrivateXml(string LocalName, string Namespace);
 
        #endregion
 
        #region PubSub
 
        Task<Item[]?> GetAllNodeIdsAsync();
 
        Task<PubSubItem[]?> GetItemsAsync(string NodeId);
 
        Task<PubSubItem[]?> GetItemsAsync(string NodeId, string[] ItemIds);
 
        Task<PubSubPageResult?> GetItemsPageAsync(string NodeId, string? ServiceAddress = null, string? After = null, string? Before = null, int? Index = null, int? Max = null);
 
        Task<PubSubItem?> GetItemAsync(string NodeId, string ItemId);
 
        Task<PubSubItem[]?> GetLatestItemsAsync(string NodeId, int Count);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> CreateNodeAsync(string NodeId, NodeConfiguration? Config = null);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryCreateNodeAsync(string NodeId, NodeConfiguration? Config = null);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> DeleteNodeAsync(string NodeId, string? RedirectUri = null);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryDeleteNodeAsync(string NodeId, string? RedirectUri = null);
 
        Task<SubscriptionEventArgs> SubscribeAsync(string NodeId, string? Jid = null, SubscriptionOptions? Options = null);
 
        Task<SubscriptionEventArgs?> TrySubscribeAsync(string NodeId, string? Jid = null, SubscriptionOptions? Options = null);
 
        Task<SubscriptionEventArgs> UnsubscribeAsync(string NodeId, string? Jid = null, string? SubscriptionId = null);
 
        Task<SubscriptionEventArgs?> TryUnsubscribeAsync(string NodeId, string? Jid = null, string? SubscriptionId = null);
 
        Task<ItemResultEventArgs> PublishAsync(string NodeId, string? ItemId = null, string PayloadXml = "");
 
        Task<ItemResultEventArgs?> TryPublishAsync(string NodeId, string? ItemId = null, string PayloadXml = "");
 
        Task<IqResultEventArgs> RetractAsync(string NodeId, string ItemId);
 
        Task<IqResultEventArgs?> TryRetractAsync(string NodeId, string ItemId);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs> PurgeNodeAsync(string NodeId);
 
        Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryPurgeNodeAsync(string NodeId);
 
 
        /*
        // Server-pushed events:
        event EventHandlerAsync<ItemNotificationEventArgs> ItemNotification;
        event EventHandlerAsync<ItemNotificationEventArgs> ItemRetracted;
        event EventHandlerAsync<NodeNotificationEventArgs> NodePurged;
        event EventHandlerAsync<SubscriptionNotificationEventArgs> SubscriptionStatusChanged;
        event EventHandlerAsync<SubscriptionRequestEventArgs> SubscriptionRequest;
        event EventHandlerAsync<AffiliationNotificationEventArgs> AffiliationNotification;
        */
        #endregion
 
        #region Debugging
 
        ISniffer[] RemoteSniffers { get; }
 
        #endregion
    }
}