Admin.h

// Copyright (c) ZeroC, Inc.
 
// slice2cpp version 3.8.0-alpha.0
// <auto-generated>Generated from Slice file 'Admin.ice'.</auto-generated>
// clang-format off
 
#ifndef IceGrid_Admin_h_
#define IceGrid_Admin_h_
 
#include <Ice/PushDisableWarnings.h>
#include <Ice/Ice.h>
#include "Descriptor.h"
#include "Exception.h"
#include <Glacier2/Session.h>
#include <IceGrid/Config.h>
 
#ifndef ICE_DISABLE_VERSION
#   if ICE_INT_VERSION  != 30850
#       error Ice version mismatch: an exact match is required for beta generated code
#   endif
#endif
 
#ifndef ICEGRID_API
#   if defined(ICEGRID_API_EXPORTS)
#       define ICEGRID_API ICE_DECLSPEC_EXPORT
#   else
#       define ICEGRID_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
// NOLINTBEGIN(modernize-concat-nested-namespaces)
 
namespace IceGrid
{
    class RegistryPrx;
 
    /// Represents the state of a server.
    enum class ServerState : std::uint8_t
    {
        /// The server is not running.
        Inactive,
 
        /// The server is being activated and will change to the active state when the registered server object adapters
        /// are activated or to the activation timed out state if the activation timeout expires.
        Activating,
 
        /// The server activation timed out.
        ActivationTimedOut,
 
        /// The server is running.
        Active,
 
        /// The server is being deactivated.
        Deactivating,
 
        /// The server is being destroyed.
        Destroying,
 
        /// The server is destroyed.
        Destroyed
    };
 
    /// Outputs the enumerator name or underlying value of a ServerState to a stream.
    /// @param os The output stream.
    /// @param value The value to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, ServerState value);
 
    /// A dictionary of string to proxies.
    using StringObjectProxyDict = std::map<std::string, std::optional<Ice::ObjectPrx>>;
 
    struct ObjectInfo;
 
    /// A sequence of ObjectInfo.
    using ObjectInfoSeq = std::vector<ObjectInfo>;
 
    struct AdapterInfo;
 
    /// A sequence of AdapterInfo.
    using AdapterInfoSeq = std::vector<AdapterInfo>;
 
    struct ServerInfo;
 
    struct NodeInfo;
 
    struct RegistryInfo;
 
    /// A sequence of RegistryInfo.
    using RegistryInfoSeq = std::vector<RegistryInfo>;
 
    struct LoadInfo;
 
    struct ApplicationInfo;
 
    /// A sequence of ApplicationInfo.
    using ApplicationInfoSeq = std::vector<ApplicationInfo>;
 
    struct ApplicationUpdateInfo;
 
    class AdminPrx;
 
    class FileIteratorPrx;
 
    struct ServerDynamicInfo;
 
    /// A sequence of ServerDynamicInfo.
    using ServerDynamicInfoSeq = std::vector<ServerDynamicInfo>;
 
    struct AdapterDynamicInfo;
 
    /// A sequence of AdapterDynamicInfo.
    using AdapterDynamicInfoSeq = std::vector<AdapterDynamicInfo>;
 
    struct NodeDynamicInfo;
 
    class RegistryObserverPrx;
 
    /// A sequence of NodeDynamicInfo.
    using NodeDynamicInfoSeq = std::vector<NodeDynamicInfo>;
 
    class NodeObserverPrx;
 
    class ApplicationObserverPrx;
 
    class AdapterObserverPrx;
 
    class ObjectObserverPrx;
 
    class AdminSessionPrx;
}
 
namespace IceGrid
{
    /// Provides administrative access to an IceGrid deployment.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdminPrx : public Ice::Proxy<AdminPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        AdminPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        AdminPrx(const AdminPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        AdminPrx(AdminPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~AdminPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        AdminPrx& operator=(const AdminPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        AdminPrx& operator=(AdminPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Adds an application to IceGrid.
        /// @param descriptor The application descriptor.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void addApplication(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an application to IceGrid.
        /// @param descriptor The application descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> addApplicationAsync(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an application to IceGrid.
        /// @param descriptor The application descriptor.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> addApplicationAsync(const ApplicationDescriptor& descriptor, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_addApplication(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ApplicationDescriptor&, const Ice::Context&) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor.
        /// @param descriptor The new application descriptor.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void syncApplication(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor.
        /// @param descriptor The new application descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> syncApplicationAsync(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor.
        /// @param descriptor The new application descriptor.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> syncApplicationAsync(const ApplicationDescriptor& descriptor, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_syncApplication(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ApplicationDescriptor&, const Ice::Context&) const;
 
        /// Updates a deployed application.
        /// @param descriptor The update descriptor.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void updateApplication(const ApplicationUpdateDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates a deployed application.
        /// @param descriptor The update descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> updateApplicationAsync(const ApplicationUpdateDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates a deployed application.
        /// @param descriptor The update descriptor.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> updateApplicationAsync(const ApplicationUpdateDescriptor& descriptor, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_updateApplication(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ApplicationUpdateDescriptor&, const Ice::Context&) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor
        /// only if no server restarts are necessary for the update of the application. If some servers need to be
        /// restarted, the synchronization is rejected with a DeploymentException.
        /// @param descriptor The application descriptor.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void syncApplicationWithoutRestart(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor
        /// only if no server restarts are necessary for the update of the application. If some servers need to be
        /// restarted, the synchronization is rejected with a DeploymentException.
        /// @param descriptor The application descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> syncApplicationWithoutRestartAsync(const ApplicationDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor
        /// only if no server restarts are necessary for the update of the application. If some servers need to be
        /// restarted, the synchronization is rejected with a DeploymentException.
        /// @param descriptor The application descriptor.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> syncApplicationWithoutRestartAsync(const ApplicationDescriptor& descriptor, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_syncApplicationWithoutRestart(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ApplicationDescriptor&, const Ice::Context&) const;
 
        /// Updates a deployed application. This operation succeeds only when no server restarts are necessary for the
        /// update of the application. If some servers need to be restarted, the synchronization is rejected with a
        /// DeploymentException.
        /// @param descriptor The update descriptor.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void updateApplicationWithoutRestart(const ApplicationUpdateDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates a deployed application. This operation succeeds only when no server restarts are necessary for the
        /// update of the application. If some servers need to be restarted, the synchronization is rejected with a
        /// DeploymentException.
        /// @param descriptor The update descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> updateApplicationWithoutRestartAsync(const ApplicationUpdateDescriptor& descriptor, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates a deployed application. This operation succeeds only when no server restarts are necessary for the
        /// update of the application. If some servers need to be restarted, the synchronization is rejected with a
        /// DeploymentException.
        /// @param descriptor The update descriptor.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> updateApplicationWithoutRestartAsync(const ApplicationUpdateDescriptor& descriptor, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_updateApplicationWithoutRestart(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ApplicationUpdateDescriptor&, const Ice::Context&) const;
 
        /// Removes an application from IceGrid.
        /// @param name The application name.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void removeApplication(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes an application from IceGrid.
        /// @param name The application name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> removeApplicationAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes an application from IceGrid.
        /// @param name The application name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> removeApplicationAsync(std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_removeApplication(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Instantiates a server template.
        /// @param application The application name.
        /// @param node The name of the node where the server will be deployed.
        /// @param desc The descriptor of the server instance to deploy.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void instantiateServer(std::string_view application, std::string_view node, const ServerInstanceDescriptor& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Instantiates a server template.
        /// @param application The application name.
        /// @param node The name of the node where the server will be deployed.
        /// @param desc The descriptor of the server instance to deploy.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> instantiateServerAsync(std::string_view application, std::string_view node, const ServerInstanceDescriptor& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Instantiates a server template.
        /// @param application The application name.
        /// @param node The name of the node where the server will be deployed.
        /// @param desc The descriptor of the server instance to deploy.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> instantiateServerAsync(std::string_view application, std::string_view node, const ServerInstanceDescriptor& desc, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_instantiateServer(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, std::string_view, const ServerInstanceDescriptor&, const Ice::Context&) const;
 
        /// Gets an application descriptor.
        /// @param name The application name.
        /// @param context The request context.
        /// @return The application descriptor.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        ApplicationInfo getApplicationInfo(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets an application descriptor.
        /// @param name The application name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The application descriptor.
        [[nodiscard]] std::future<ApplicationInfo> getApplicationInfoAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets an application descriptor.
        /// @param name The application name.
        /// @param response The response callback. It accepts:
        /// - The application descriptor.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getApplicationInfoAsync(std::string_view name, std::function<void(::IceGrid::ApplicationInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getApplicationInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<ApplicationInfo>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the default application descriptor.
        /// @param context The request context.
        /// @return The default application descriptor.
        /// @throws IceGrid::DeploymentException Thrown when the default application descriptor is invalid or unreachable.
        ApplicationDescriptor getDefaultApplicationDescriptor(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the default application descriptor.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The default application descriptor.
        [[nodiscard]] std::future<ApplicationDescriptor> getDefaultApplicationDescriptorAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the default application descriptor.
        /// @param response The response callback. It accepts:
        /// - The default application descriptor.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getDefaultApplicationDescriptorAsync(std::function<void(::IceGrid::ApplicationDescriptor)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getDefaultApplicationDescriptor(const std::shared_ptr<IceInternal::OutgoingAsyncT<ApplicationDescriptor>>&, const Ice::Context&) const;
 
        /// Gets all the IceGrid applications currently registered.
        /// @param context The request context.
        /// @return The application names.
        ::Ice::StringSeq getAllApplicationNames(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets all the IceGrid applications currently registered.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The application names.
        [[nodiscard]] std::future<::Ice::StringSeq> getAllApplicationNamesAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets all the IceGrid applications currently registered.
        /// @param response The response callback. It accepts:
        /// - The application names.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllApplicationNamesAsync(std::function<void(::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllApplicationNames(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Gets information about a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return The server information.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        ServerInfo getServerInfo(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets information about a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The server information.
        [[nodiscard]] std::future<ServerInfo> getServerInfoAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets information about a server.
        /// @param id The server ID.
        /// @param response The response callback. It accepts:
        /// - The server information.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getServerInfoAsync(std::string_view id, std::function<void(::IceGrid::ServerInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getServerInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<ServerInfo>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the state of a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return The server state.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        ServerState getServerState(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the state of a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The server state.
        [[nodiscard]] std::future<ServerState> getServerStateAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the state of a server.
        /// @param id The server ID.
        /// @param response The response callback. It accepts:
        /// - The server state.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getServerStateAsync(std::string_view id, std::function<void(::IceGrid::ServerState)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getServerState(const std::shared_ptr<IceInternal::OutgoingAsyncT<ServerState>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the system process ID of a server. The process ID is operating system dependent.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return The process ID.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        std::int32_t getServerPid(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the system process ID of a server. The process ID is operating system dependent.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The process ID.
        [[nodiscard]] std::future<std::int32_t> getServerPidAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the system process ID of a server. The process ID is operating system dependent.
        /// @param id The server ID.
        /// @param response The response callback. It accepts:
        /// - The process ID.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getServerPidAsync(std::string_view id, std::function<void(std::int32_t)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getServerPid(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int32_t>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the category for server admin objects. You can manufacture a server admin proxy from the admin proxy by
        /// changing its identity: use the server ID as name and the returned category as category.
        /// @param context The request context.
        /// @return The category for server admin objects.
        std::string getServerAdminCategory(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the category for server admin objects. You can manufacture a server admin proxy from the admin proxy by
        /// changing its identity: use the server ID as name and the returned category as category.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The category for server admin objects.
        [[nodiscard]] std::future<std::string> getServerAdminCategoryAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the category for server admin objects. You can manufacture a server admin proxy from the admin proxy by
        /// changing its identity: use the server ID as name and the returned category as category.
        /// @param response The response callback. It accepts:
        /// - The category for server admin objects.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getServerAdminCategoryAsync(std::function<void(std::string)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getServerAdminCategory(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::string>>&, const Ice::Context&) const;
 
        /// Gets a proxy to the admin object of a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A proxy to the admin object of the server. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        std::optional<Ice::ObjectPrx> getServerAdmin(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the admin object of a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the admin object of the server. This proxy is never null.
        [[nodiscard]] std::future<std::optional<Ice::ObjectPrx>> getServerAdminAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the admin object of a server.
        /// @param id The server ID.
        /// @param response The response callback. It accepts:
        /// - A proxy to the admin object of the server. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getServerAdminAsync(std::string_view id, std::function<void(std::optional<Ice::ObjectPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getServerAdmin(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<Ice::ObjectPrx>>>&, std::string_view, const Ice::Context&) const;
 
        /// Enables or disables a server. A disabled server can't be started on demand or administratively. The enable
        /// state of the server is not persistent: if the node is shut down and restarted, the server will be enabled by
        /// default.
        /// @param id The server ID.
        /// @param enabled `true` to enable the server, `false` to disable it.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        void enableServer(std::string_view id, bool enabled, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Enables or disables a server. A disabled server can't be started on demand or administratively. The enable
        /// state of the server is not persistent: if the node is shut down and restarted, the server will be enabled by
        /// default.
        /// @param id The server ID.
        /// @param enabled `true` to enable the server, `false` to disable it.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> enableServerAsync(std::string_view id, bool enabled, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Enables or disables a server. A disabled server can't be started on demand or administratively. The enable
        /// state of the server is not persistent: if the node is shut down and restarted, the server will be enabled by
        /// default.
        /// @param id The server ID.
        /// @param enabled `true` to enable the server, `false` to disable it.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> enableServerAsync(std::string_view id, bool enabled, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_enableServer(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, bool, const Ice::Context&) const;
 
        /// Checks if the server is enabled or disabled.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return `true` if the server is enabled, `false` otherwise.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        bool isServerEnabled(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Checks if the server is enabled or disabled.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - `true` if the server is enabled, `false` otherwise.
        [[nodiscard]] std::future<bool> isServerEnabledAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Checks if the server is enabled or disabled.
        /// @param id The server ID.
        /// @param response The response callback. It accepts:
        /// - `true` if the server is enabled, `false` otherwise.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> isServerEnabledAsync(std::string_view id, std::function<void(bool)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_isServerEnabled(const std::shared_ptr<IceInternal::OutgoingAsyncT<bool>>&, std::string_view, const Ice::Context&) const;
 
        /// Starts a server and waits for its activation.
        /// @param id The server id.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        /// @throws IceGrid::ServerStartException Thrown when the server startup failed.
        void startServer(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Starts a server and waits for its activation.
        /// @param id The server id.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> startServerAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Starts a server and waits for its activation.
        /// @param id The server id.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> startServerAsync(std::string_view id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_startServer(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Stops a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        /// @throws IceGrid::ServerStopException Thrown when the server stop failed.
        void stopServer(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Stops a server.
        /// @param id The server ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> stopServerAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Stops a server.
        /// @param id The server ID.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> stopServerAsync(std::string_view id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_stopServer(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Sends a signal to a server.
        /// @param id The server ID.
        /// @param signal The signal, for example SIGTERM or 15.
        /// @param context The request context.
        /// @throws IceGrid::BadSignalException Thrown when the signal is not recognized by the target server.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        void sendSignal(std::string_view id, std::string_view signal, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sends a signal to a server.
        /// @param id The server ID.
        /// @param signal The signal, for example SIGTERM or 15.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> sendSignalAsync(std::string_view id, std::string_view signal, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sends a signal to a server.
        /// @param id The server ID.
        /// @param signal The signal, for example SIGTERM or 15.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> sendSignalAsync(std::string_view id, std::string_view signal, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_sendSignal(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, std::string_view, const Ice::Context&) const;
 
        /// Gets the IDs of all the servers registered with IceGrid.
        /// @param context The request context.
        /// @return The server IDs.
        ::Ice::StringSeq getAllServerIds(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the IDs of all the servers registered with IceGrid.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The server IDs.
        [[nodiscard]] std::future<::Ice::StringSeq> getAllServerIdsAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the IDs of all the servers registered with IceGrid.
        /// @param response The response callback. It accepts:
        /// - The server IDs.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllServerIdsAsync(std::function<void(::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllServerIds(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Gets adapter information for the replica group or adapter with the given ID.
        /// @param id The adapter or replica group ID.
        /// @param context The request context.
        /// @return A sequence of AdapterInfo. If @p id refers to an adapter, this sequence contains a single element.
        /// If @p id refers to a replica group, this sequence contains adapter information for each member of the
        /// replica group.
        /// @throws IceGrid::AdapterNotExistException Thrown when the adapter or replica group doesn't exist.
        AdapterInfoSeq getAdapterInfo(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets adapter information for the replica group or adapter with the given ID.
        /// @param id The adapter or replica group ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A sequence of AdapterInfo. If @p id refers to an adapter, this sequence contains a single element.
        /// If @p id refers to a replica group, this sequence contains adapter information for each member of the
        /// replica group.
        [[nodiscard]] std::future<AdapterInfoSeq> getAdapterInfoAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets adapter information for the replica group or adapter with the given ID.
        /// @param id The adapter or replica group ID.
        /// @param response The response callback. It accepts:
        /// - A sequence of AdapterInfo. If @p id refers to an adapter, this sequence contains a single element.
        /// If @p id refers to a replica group, this sequence contains adapter information for each member of the
        /// replica group.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAdapterInfoAsync(std::string_view id, std::function<void(::IceGrid::AdapterInfoSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAdapterInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<AdapterInfoSeq>>&, std::string_view, const Ice::Context&) const;
 
        /// Removes the adapter with the given ID.
        /// @param id The adapter ID.
        /// @param context The request context.
        /// @throws IceGrid::AdapterNotExistException Thrown when the adapter doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        void removeAdapter(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes the adapter with the given ID.
        /// @param id The adapter ID.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> removeAdapterAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes the adapter with the given ID.
        /// @param id The adapter ID.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> removeAdapterAsync(std::string_view id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_removeAdapter(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the IDs of all adapters registered with IceGrid.
        /// @param context The request context.
        /// @return The adapter IDs.
        ::Ice::StringSeq getAllAdapterIds(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the IDs of all adapters registered with IceGrid.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The adapter IDs.
        [[nodiscard]] std::future<::Ice::StringSeq> getAllAdapterIdsAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the IDs of all adapters registered with IceGrid.
        /// @param response The response callback. It accepts:
        /// - The adapter IDs.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllAdapterIdsAsync(std::function<void(::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllAdapterIds(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Adds an object to the object registry. IceGrid gets the object type by calling `ice_id` on @p obj. The
        /// object must be reachable.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be added.
        /// @throws IceGrid::ObjectExistsException Thrown when the object is already registered.
        void addObject(const std::optional<Ice::ObjectPrx>& obj, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an object to the object registry. IceGrid gets the object type by calling `ice_id` on @p obj. The
        /// object must be reachable.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> addObjectAsync(const std::optional<Ice::ObjectPrx>& obj, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an object to the object registry. IceGrid gets the object type by calling `ice_id` on @p obj. The
        /// object must be reachable.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> addObjectAsync(const std::optional<Ice::ObjectPrx>& obj, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_addObject(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const std::optional<Ice::ObjectPrx>&, const Ice::Context&) const;
 
        /// Updates an object in the object registry. Only objects added with this interface can be updated with this
        /// operation. Objects added with deployment descriptors should be updated with the deployment mechanism.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be updated.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        void updateObject(const std::optional<Ice::ObjectPrx>& obj, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates an object in the object registry. Only objects added with this interface can be updated with this
        /// operation. Objects added with deployment descriptors should be updated with the deployment mechanism.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> updateObjectAsync(const std::optional<Ice::ObjectPrx>& obj, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Updates an object in the object registry. Only objects added with this interface can be updated with this
        /// operation. Objects added with deployment descriptors should be updated with the deployment mechanism.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> updateObjectAsync(const std::optional<Ice::ObjectPrx>& obj, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_updateObject(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const std::optional<Ice::ObjectPrx>&, const Ice::Context&) const;
 
        /// Adds an object to the object registry and explicitly specifies its type.
        /// @param obj The object to be added to the registry. The proxy is never null.
        /// @param type The type name.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        /// @throws IceGrid::ObjectExistsException Thrown when the object is already registered.
        void addObjectWithType(const std::optional<Ice::ObjectPrx>& obj, std::string_view type, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an object to the object registry and explicitly specifies its type.
        /// @param obj The object to be added to the registry. The proxy is never null.
        /// @param type The type name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> addObjectWithTypeAsync(const std::optional<Ice::ObjectPrx>& obj, std::string_view type, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Adds an object to the object registry and explicitly specifies its type.
        /// @param obj The object to be added to the registry. The proxy is never null.
        /// @param type The type name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> addObjectWithTypeAsync(const std::optional<Ice::ObjectPrx>& obj, std::string_view type, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_addObjectWithType(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const std::optional<Ice::ObjectPrx>&, std::string_view, const Ice::Context&) const;
 
        /// Removes an object from the object registry. Only objects added with this interface can be removed with this
        /// operation. Objects added with deployment descriptors should be removed with the deployment mechanism.
        /// @param id The identity of the object to remove.
        /// @param context The request context.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be removed.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        void removeObject(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes an object from the object registry. Only objects added with this interface can be removed with this
        /// operation. Objects added with deployment descriptors should be removed with the deployment mechanism.
        /// @param id The identity of the object to remove.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> removeObjectAsync(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Removes an object from the object registry. Only objects added with this interface can be removed with this
        /// operation. Objects added with deployment descriptors should be removed with the deployment mechanism.
        /// @param id The identity of the object to remove.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> removeObjectAsync(const ::Ice::Identity& id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_removeObject(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Identity&, const Ice::Context&) const;
 
        /// Gets the object info for the object.
        /// @param id The identity of the object.
        /// @param context The request context.
        /// @return The object info.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        ObjectInfo getObjectInfo(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the object info for the object.
        /// @param id The identity of the object.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The object info.
        [[nodiscard]] std::future<ObjectInfo> getObjectInfoAsync(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the object info for the object.
        /// @param id The identity of the object.
        /// @param response The response callback. It accepts:
        /// - The object info.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getObjectInfoAsync(const ::Ice::Identity& id, std::function<void(::IceGrid::ObjectInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getObjectInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<ObjectInfo>>&, const ::Ice::Identity&, const Ice::Context&) const;
 
        /// Gets the object info of all the registered objects with a given type.
        /// @param type The type name.
        /// @param context The request context.
        /// @return The object infos.
        ObjectInfoSeq getObjectInfosByType(std::string_view type, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the object info of all the registered objects with a given type.
        /// @param type The type name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The object infos.
        [[nodiscard]] std::future<ObjectInfoSeq> getObjectInfosByTypeAsync(std::string_view type, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the object info of all the registered objects with a given type.
        /// @param type The type name.
        /// @param response The response callback. It accepts:
        /// - The object infos.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getObjectInfosByTypeAsync(std::string_view type, std::function<void(::IceGrid::ObjectInfoSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getObjectInfosByType(const std::shared_ptr<IceInternal::OutgoingAsyncT<ObjectInfoSeq>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the object info of all the registered objects whose stringified identities match the given expression.
        /// @param expr The expression to match against the stringified identities of registered objects. The expression
        /// may contain a trailing wildcard (`*`) character.
        /// @param context The request context.
        /// @return All the object infos with a stringified identity matching the given expression.
        ObjectInfoSeq getAllObjectInfos(std::string_view expr, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the object info of all the registered objects whose stringified identities match the given expression.
        /// @param expr The expression to match against the stringified identities of registered objects. The expression
        /// may contain a trailing wildcard (`*`) character.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - All the object infos with a stringified identity matching the given expression.
        [[nodiscard]] std::future<ObjectInfoSeq> getAllObjectInfosAsync(std::string_view expr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the object info of all the registered objects whose stringified identities match the given expression.
        /// @param expr The expression to match against the stringified identities of registered objects. The expression
        /// may contain a trailing wildcard (`*`) character.
        /// @param response The response callback. It accepts:
        /// - All the object infos with a stringified identity matching the given expression.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllObjectInfosAsync(std::string_view expr, std::function<void(::IceGrid::ObjectInfoSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllObjectInfos(const std::shared_ptr<IceInternal::OutgoingAsyncT<ObjectInfoSeq>>&, std::string_view, const Ice::Context&) const;
 
        /// Pings an IceGrid node to see if it is active.
        /// @param name The node name.
        /// @param context The request context.
        /// @return `true` if the node ping succeeded, `false` otherwise.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        bool pingNode(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Pings an IceGrid node to see if it is active.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - `true` if the node ping succeeded, `false` otherwise.
        [[nodiscard]] std::future<bool> pingNodeAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Pings an IceGrid node to see if it is active.
        /// @param name The node name.
        /// @param response The response callback. It accepts:
        /// - `true` if the node ping succeeded, `false` otherwise.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> pingNodeAsync(std::string_view name, std::function<void(bool)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_pingNode(const std::shared_ptr<IceInternal::OutgoingAsyncT<bool>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the load averages of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return The node load information.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        LoadInfo getNodeLoad(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the load averages of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The node load information.
        [[nodiscard]] std::future<LoadInfo> getNodeLoadAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the load averages of a node.
        /// @param name The node name.
        /// @param response The response callback. It accepts:
        /// - The node load information.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getNodeLoadAsync(std::string_view name, std::function<void(::IceGrid::LoadInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getNodeLoad(const std::shared_ptr<IceInternal::OutgoingAsyncT<LoadInfo>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the node information of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return The node information.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        NodeInfo getNodeInfo(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the node information of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The node information.
        [[nodiscard]] std::future<NodeInfo> getNodeInfoAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the node information of a node.
        /// @param name The node name.
        /// @param response The response callback. It accepts:
        /// - The node information.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getNodeInfoAsync(std::string_view name, std::function<void(::IceGrid::NodeInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getNodeInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<NodeInfo>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets a proxy to the admin object of an IceGrid node.
        /// @param name The IceGrid node name.
        /// @param context The request context.
        /// @return A proxy to the IceGrid node's admin object. This proxy is never null.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        std::optional<Ice::ObjectPrx> getNodeAdmin(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the admin object of an IceGrid node.
        /// @param name The IceGrid node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the IceGrid node's admin object. This proxy is never null.
        [[nodiscard]] std::future<std::optional<Ice::ObjectPrx>> getNodeAdminAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the admin object of an IceGrid node.
        /// @param name The IceGrid node name.
        /// @param response The response callback. It accepts:
        /// - A proxy to the IceGrid node's admin object. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getNodeAdminAsync(std::string_view name, std::function<void(std::optional<Ice::ObjectPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getNodeAdmin(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<Ice::ObjectPrx>>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the number of physical processor sockets in the computer where an IceGrid node is deployed.
        /// Note that this operation returns 1 on operating systems where this can't be automatically determined and
        /// where the `IceGrid.Node.ProcessorSocketCount` property for the node is not set.
        /// @param name The node name.
        /// @param context The request context.
        /// @return The number of processor sockets or 1 if the number of sockets can't be determined.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        std::int32_t getNodeProcessorSocketCount(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the number of physical processor sockets in the computer where an IceGrid node is deployed.
        /// Note that this operation returns 1 on operating systems where this can't be automatically determined and
        /// where the `IceGrid.Node.ProcessorSocketCount` property for the node is not set.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The number of processor sockets or 1 if the number of sockets can't be determined.
        [[nodiscard]] std::future<std::int32_t> getNodeProcessorSocketCountAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the number of physical processor sockets in the computer where an IceGrid node is deployed.
        /// Note that this operation returns 1 on operating systems where this can't be automatically determined and
        /// where the `IceGrid.Node.ProcessorSocketCount` property for the node is not set.
        /// @param name The node name.
        /// @param response The response callback. It accepts:
        /// - The number of processor sockets or 1 if the number of sockets can't be determined.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getNodeProcessorSocketCountAsync(std::string_view name, std::function<void(std::int32_t)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getNodeProcessorSocketCount(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int32_t>>&, std::string_view, const Ice::Context&) const;
 
        /// Shuts down an IceGrid node.
        /// @param name The node name.
        /// @param context The request context.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        void shutdownNode(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down an IceGrid node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> shutdownNodeAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down an IceGrid node.
        /// @param name The node name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> shutdownNodeAsync(std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_shutdownNode(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Get the hostname of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return The node hostname.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        std::string getNodeHostname(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Get the hostname of a node.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The node hostname.
        [[nodiscard]] std::future<std::string> getNodeHostnameAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Get the hostname of a node.
        /// @param name The node name.
        /// @param response The response callback. It accepts:
        /// - The node hostname.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getNodeHostnameAsync(std::string_view name, std::function<void(std::string)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getNodeHostname(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::string>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the names of all IceGrid nodes currently registered.
        /// @param context The request context.
        /// @return The node names.
        ::Ice::StringSeq getAllNodeNames(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the names of all IceGrid nodes currently registered.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The node names.
        [[nodiscard]] std::future<::Ice::StringSeq> getAllNodeNamesAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the names of all IceGrid nodes currently registered.
        /// @param response The response callback. It accepts:
        /// - The node names.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllNodeNamesAsync(std::function<void(::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllNodeNames(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Pings an IceGrid registry to see if it is active.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return `true` if the registry ping succeeded, `false` otherwise.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        bool pingRegistry(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Pings an IceGrid registry to see if it is active.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - `true` if the registry ping succeeded, `false` otherwise.
        [[nodiscard]] std::future<bool> pingRegistryAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Pings an IceGrid registry to see if it is active.
        /// @param name The registry name.
        /// @param response The response callback. It accepts:
        /// - `true` if the registry ping succeeded, `false` otherwise.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> pingRegistryAsync(std::string_view name, std::function<void(bool)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_pingRegistry(const std::shared_ptr<IceInternal::OutgoingAsyncT<bool>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the registry information of an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return The registry information.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        RegistryInfo getRegistryInfo(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the registry information of an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The registry information.
        [[nodiscard]] std::future<RegistryInfo> getRegistryInfoAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the registry information of an IceGrid registry.
        /// @param name The registry name.
        /// @param response The response callback. It accepts:
        /// - The registry information.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getRegistryInfoAsync(std::string_view name, std::function<void(::IceGrid::RegistryInfo)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getRegistryInfo(const std::shared_ptr<IceInternal::OutgoingAsyncT<RegistryInfo>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets a proxy to the admin object of an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A proxy to the admin object of an IceGrid registry. This proxy is never null.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        std::optional<Ice::ObjectPrx> getRegistryAdmin(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the admin object of an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the admin object of an IceGrid registry. This proxy is never null.
        [[nodiscard]] std::future<std::optional<Ice::ObjectPrx>> getRegistryAdminAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the admin object of an IceGrid registry.
        /// @param name The registry name.
        /// @param response The response callback. It accepts:
        /// - A proxy to the admin object of an IceGrid registry. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getRegistryAdminAsync(std::string_view name, std::function<void(std::optional<Ice::ObjectPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getRegistryAdmin(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<Ice::ObjectPrx>>>&, std::string_view, const Ice::Context&) const;
 
        /// Shuts down an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        void shutdownRegistry(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down an IceGrid registry.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> shutdownRegistryAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down an IceGrid registry.
        /// @param name The registry name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> shutdownRegistryAsync(std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_shutdownRegistry(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the names of all the IceGrid registries currently registered.
        /// @param context The request context.
        /// @return The registry names.
        ::Ice::StringSeq getAllRegistryNames(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the names of all the IceGrid registries currently registered.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The registry names.
        [[nodiscard]] std::future<::Ice::StringSeq> getAllRegistryNamesAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the names of all the IceGrid registries currently registered.
        /// @param response The response callback. It accepts:
        /// - The registry names.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAllRegistryNamesAsync(std::function<void(::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAllRegistryNames(const std::shared_ptr<IceInternal::OutgoingAsyncT<::Ice::StringSeq>>&, const Ice::Context&) const;
 
        /// Shuts down the IceGrid registry.
        /// @param context The request context.
        void shutdown(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down the IceGrid registry.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> shutdownAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Shuts down the IceGrid registry.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> shutdownAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_shutdown(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::Admin"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static AdminPrx _fromReference(IceInternal::ReferencePtr ref) { return AdminPrx{std::move(ref)}; }
 
    protected:
        /// @private
        AdminPrx() = default;
 
        /// @private
        explicit AdminPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Iterates over an IceGrid log file.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API FileIteratorPrx : public Ice::Proxy<FileIteratorPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        FileIteratorPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        FileIteratorPrx(const FileIteratorPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        FileIteratorPrx(FileIteratorPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~FileIteratorPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        FileIteratorPrx& operator=(const FileIteratorPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        FileIteratorPrx& operator=(FileIteratorPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Read lines from the log file.
        /// @param size Specifies the maximum number of bytes to be received. The server will ensure that the returned
        /// message doesn't exceed the given size.
        /// @param[out] lines The lines read from the file. If there was nothing to read from the file since the last call to
        /// read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
        /// newline character should be added when writing the last line to the to the output device).
        /// @param context The request context.
        /// @return `true` if EOF is encountered.
        /// @throws IceGrid::FileNotAvailableException Thrown when the implementation failed to read from the file.
        bool read(std::int32_t size, ::Ice::StringSeq& lines, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Read lines from the log file.
        /// @param size Specifies the maximum number of bytes to be received. The server will ensure that the returned
        /// message doesn't exceed the given size.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - `returnValue` `true` if EOF is encountered.
        /// - `lines` The lines read from the file. If there was nothing to read from the file since the last call to
        /// read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
        /// newline character should be added when writing the last line to the to the output device).
        [[nodiscard]] std::future<std::tuple<bool, ::Ice::StringSeq>> readAsync(std::int32_t size, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Read lines from the log file.
        /// @param size Specifies the maximum number of bytes to be received. The server will ensure that the returned
        /// message doesn't exceed the given size.
        /// @param response The response callback. It accepts:
        /// - `returnValue` `true` if EOF is encountered.
        /// - `lines` The lines read from the file. If there was nothing to read from the file since the last call to
        /// read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
        /// newline character should be added when writing the last line to the to the output device).
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> readAsync(std::int32_t size, std::function<void(bool, ::Ice::StringSeq)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_read(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::tuple<bool, ::Ice::StringSeq>>>&, std::int32_t, const Ice::Context&) const;
 
        /// Destroys the iterator.
        /// @param context The request context.
        void destroy(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the iterator.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> destroyAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Destroys the iterator.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> destroyAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_destroy(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::FileIterator"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static FileIteratorPrx _fromReference(IceInternal::ReferencePtr ref) { return FileIteratorPrx{std::move(ref)}; }
 
    protected:
        /// @private
        FileIteratorPrx() = default;
 
        /// @private
        explicit FileIteratorPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Monitors changes to the state of the registries.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RegistryObserverPrx : public Ice::Proxy<RegistryObserverPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        RegistryObserverPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        RegistryObserverPrx(const RegistryObserverPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        RegistryObserverPrx(RegistryObserverPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~RegistryObserverPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        RegistryObserverPrx& operator=(const RegistryObserverPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        RegistryObserverPrx& operator=(RegistryObserverPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Provides the initial state of the registries to the observer.
        /// @param registries The current state of the registries.
        /// @param context The request context.
        void registryInit(const RegistryInfoSeq& registries, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial state of the registries to the observer.
        /// @param registries The current state of the registries.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> registryInitAsync(const RegistryInfoSeq& registries, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial state of the registries to the observer.
        /// @param registries The current state of the registries.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> registryInitAsync(const RegistryInfoSeq& registries, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_registryInit(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const RegistryInfoSeq&, const Ice::Context&) const;
 
        /// Notifies the observer that a registry replica came up.
        /// @param registryReplica The registry state.
        /// @param context The request context.
        void registryUp(const RegistryInfo& registryReplica, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a registry replica came up.
        /// @param registryReplica The registry state.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> registryUpAsync(const RegistryInfo& registryReplica, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a registry replica came up.
        /// @param registryReplica The registry state.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> registryUpAsync(const RegistryInfo& registryReplica, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_registryUp(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const RegistryInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that a registry replica went down.
        /// @param name The registry name.
        /// @param context The request context.
        void registryDown(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a registry replica went down.
        /// @param name The registry name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> registryDownAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a registry replica went down.
        /// @param name The registry name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> registryDownAsync(std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_registryDown(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::RegistryObserver"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static RegistryObserverPrx _fromReference(IceInternal::ReferencePtr ref) { return RegistryObserverPrx{std::move(ref)}; }
 
    protected:
        /// @private
        RegistryObserverPrx() = default;
 
        /// @private
        explicit RegistryObserverPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Monitors changes to the state of the nodes.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API NodeObserverPrx : public Ice::Proxy<NodeObserverPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        NodeObserverPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        NodeObserverPrx(const NodeObserverPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        NodeObserverPrx(NodeObserverPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~NodeObserverPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        NodeObserverPrx& operator=(const NodeObserverPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        NodeObserverPrx& operator=(NodeObserverPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Provides the initial state of the nodes to the observer.
        /// @param nodes The current state of the nodes.
        /// @param context The request context.
        void nodeInit(const NodeDynamicInfoSeq& nodes, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial state of the nodes to the observer.
        /// @param nodes The current state of the nodes.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> nodeInitAsync(const NodeDynamicInfoSeq& nodes, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial state of the nodes to the observer.
        /// @param nodes The current state of the nodes.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> nodeInitAsync(const NodeDynamicInfoSeq& nodes, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_nodeInit(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const NodeDynamicInfoSeq&, const Ice::Context&) const;
 
        /// Notifies the observer that a node came up.
        /// @param node The node state.
        /// @param context The request context.
        void nodeUp(const NodeDynamicInfo& node, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a node came up.
        /// @param node The node state.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> nodeUpAsync(const NodeDynamicInfo& node, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a node came up.
        /// @param node The node state.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> nodeUpAsync(const NodeDynamicInfo& node, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_nodeUp(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const NodeDynamicInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that a node went down.
        /// @param name The node name.
        /// @param context The request context.
        void nodeDown(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a node went down.
        /// @param name The node name.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> nodeDownAsync(std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a node went down.
        /// @param name The node name.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> nodeDownAsync(std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_nodeDown(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Notifies the observer that the state of a server changed.
        /// @param node The node hosting the server.
        /// @param updatedInfo The new server state.
        /// @param context The request context.
        void updateServer(std::string_view node, const ServerDynamicInfo& updatedInfo, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that the state of a server changed.
        /// @param node The node hosting the server.
        /// @param updatedInfo The new server state.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> updateServerAsync(std::string_view node, const ServerDynamicInfo& updatedInfo, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that the state of a server changed.
        /// @param node The node hosting the server.
        /// @param updatedInfo The new server state.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> updateServerAsync(std::string_view node, const ServerDynamicInfo& updatedInfo, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_updateServer(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const ServerDynamicInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that the state of an object adapter changed.
        /// @param node The node hosting the adapter.
        /// @param updatedInfo The new adapter state.
        /// @param context The request context.
        void updateAdapter(std::string_view node, const AdapterDynamicInfo& updatedInfo, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that the state of an object adapter changed.
        /// @param node The node hosting the adapter.
        /// @param updatedInfo The new adapter state.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> updateAdapterAsync(std::string_view node, const AdapterDynamicInfo& updatedInfo, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that the state of an object adapter changed.
        /// @param node The node hosting the adapter.
        /// @param updatedInfo The new adapter state.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> updateAdapterAsync(std::string_view node, const AdapterDynamicInfo& updatedInfo, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_updateAdapter(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const AdapterDynamicInfo&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::NodeObserver"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static NodeObserverPrx _fromReference(IceInternal::ReferencePtr ref) { return NodeObserverPrx{std::move(ref)}; }
 
    protected:
        /// @private
        NodeObserverPrx() = default;
 
        /// @private
        explicit NodeObserverPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Monitors applications.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ApplicationObserverPrx : public Ice::Proxy<ApplicationObserverPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        ApplicationObserverPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        ApplicationObserverPrx(const ApplicationObserverPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        ApplicationObserverPrx(ApplicationObserverPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~ApplicationObserverPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        ApplicationObserverPrx& operator=(const ApplicationObserverPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        ApplicationObserverPrx& operator=(ApplicationObserverPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Provides the initial application infos to the observer.
        /// @param serial The current serial number of the registry database. This serial number allows observers to
        /// make sure that their internal state is synchronized with the registry.
        /// @param applications The applications currently registered with the registry.
        /// @param context The request context.
        void applicationInit(std::int32_t serial, const ApplicationInfoSeq& applications, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial application infos to the observer.
        /// @param serial The current serial number of the registry database. This serial number allows observers to
        /// make sure that their internal state is synchronized with the registry.
        /// @param applications The applications currently registered with the registry.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> applicationInitAsync(std::int32_t serial, const ApplicationInfoSeq& applications, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial application infos to the observer.
        /// @param serial The current serial number of the registry database. This serial number allows observers to
        /// make sure that their internal state is synchronized with the registry.
        /// @param applications The applications currently registered with the registry.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> applicationInitAsync(std::int32_t serial, const ApplicationInfoSeq& applications, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_applicationInit(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::int32_t, const ApplicationInfoSeq&, const Ice::Context&) const;
 
        /// Notifies the observer that an application was added.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the new application.
        /// @param context The request context.
        void applicationAdded(std::int32_t serial, const ApplicationInfo& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was added.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the new application.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> applicationAddedAsync(std::int32_t serial, const ApplicationInfo& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was added.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the new application.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> applicationAddedAsync(std::int32_t serial, const ApplicationInfo& desc, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_applicationAdded(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::int32_t, const ApplicationInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that an application was removed.
        /// @param serial The new serial number of the registry database.
        /// @param name The name of the application that was removed.
        /// @param context The request context.
        void applicationRemoved(std::int32_t serial, std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was removed.
        /// @param serial The new serial number of the registry database.
        /// @param name The name of the application that was removed.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> applicationRemovedAsync(std::int32_t serial, std::string_view name, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was removed.
        /// @param serial The new serial number of the registry database.
        /// @param name The name of the application that was removed.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> applicationRemovedAsync(std::int32_t serial, std::string_view name, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_applicationRemoved(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::int32_t, std::string_view, const Ice::Context&) const;
 
        /// Notifies the observer that an application was updated.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the update.
        /// @param context The request context.
        void applicationUpdated(std::int32_t serial, const ApplicationUpdateInfo& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was updated.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the update.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> applicationUpdatedAsync(std::int32_t serial, const ApplicationUpdateInfo& desc, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that an application was updated.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the update.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> applicationUpdatedAsync(std::int32_t serial, const ApplicationUpdateInfo& desc, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_applicationUpdated(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::int32_t, const ApplicationUpdateInfo&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::ApplicationObserver"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static ApplicationObserverPrx _fromReference(IceInternal::ReferencePtr ref) { return ApplicationObserverPrx{std::move(ref)}; }
 
    protected:
        /// @private
        ApplicationObserverPrx() = default;
 
        /// @private
        explicit ApplicationObserverPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Monitors dynamically-registered object adapters.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdapterObserverPrx : public Ice::Proxy<AdapterObserverPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        AdapterObserverPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        AdapterObserverPrx(const AdapterObserverPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        AdapterObserverPrx(AdapterObserverPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~AdapterObserverPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        AdapterObserverPrx& operator=(const AdapterObserverPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        AdapterObserverPrx& operator=(AdapterObserverPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Provides the initial list of dynamically registered adapters to the observer.
        /// @param adpts The adapters that were dynamically registered with the registry.
        /// @param context The request context.
        void adapterInit(const AdapterInfoSeq& adpts, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial list of dynamically registered adapters to the observer.
        /// @param adpts The adapters that were dynamically registered with the registry.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> adapterInitAsync(const AdapterInfoSeq& adpts, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial list of dynamically registered adapters to the observer.
        /// @param adpts The adapters that were dynamically registered with the registry.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> adapterInitAsync(const AdapterInfoSeq& adpts, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_adapterInit(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const AdapterInfoSeq&, const Ice::Context&) const;
 
        /// Notifies the observer that a dynamically-registered adapter was added.
        /// @param info The details of the new adapter.
        /// @param context The request context.
        void adapterAdded(const AdapterInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a dynamically-registered adapter was added.
        /// @param info The details of the new adapter.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> adapterAddedAsync(const AdapterInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a dynamically-registered adapter was added.
        /// @param info The details of the new adapter.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> adapterAddedAsync(const AdapterInfo& info, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_adapterAdded(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const AdapterInfo&, const Ice::Context&) const;
 
        /// @param info The details of the updated adapter.
        /// @param context The request context.
        void adapterUpdated(const AdapterInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @param info The details of the updated adapter.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> adapterUpdatedAsync(const AdapterInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @param info The details of the updated adapter.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> adapterUpdatedAsync(const AdapterInfo& info, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_adapterUpdated(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const AdapterInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that a dynamically-registered adapter was removed.
        /// @param id The ID of the removed adapter.
        /// @param context The request context.
        void adapterRemoved(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a dynamically-registered adapter was removed.
        /// @param id The ID of the removed adapter.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> adapterRemovedAsync(std::string_view id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a dynamically-registered adapter was removed.
        /// @param id The ID of the removed adapter.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> adapterRemovedAsync(std::string_view id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_adapterRemoved(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, std::string_view, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::AdapterObserver"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static AdapterObserverPrx _fromReference(IceInternal::ReferencePtr ref) { return AdapterObserverPrx{std::move(ref)}; }
 
    protected:
        /// @private
        AdapterObserverPrx() = default;
 
        /// @private
        explicit AdapterObserverPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Monitors well-known objects that are added, updated or removed using AdminPrx.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ObjectObserverPrx : public Ice::Proxy<ObjectObserverPrx, Ice::ObjectPrx>
    {
    public:
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        ObjectObserverPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        ObjectObserverPrx(const ObjectObserverPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        ObjectObserverPrx(ObjectObserverPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~ObjectObserverPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        ObjectObserverPrx& operator=(const ObjectObserverPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        ObjectObserverPrx& operator=(ObjectObserverPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Provides the initial list of well-known objects to the observer.
        /// @param objects The well-known objects registered using ::IceGrid::AdminPrx.
        /// @param context The request context.
        void objectInit(const ObjectInfoSeq& objects, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial list of well-known objects to the observer.
        /// @param objects The well-known objects registered using ::IceGrid::AdminPrx.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> objectInitAsync(const ObjectInfoSeq& objects, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Provides the initial list of well-known objects to the observer.
        /// @param objects The well-known objects registered using ::IceGrid::AdminPrx.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> objectInitAsync(const ObjectInfoSeq& objects, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_objectInit(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ObjectInfoSeq&, const Ice::Context&) const;
 
        /// Notifies the observer that a well-known object was added.
        /// @param info The details of the new object.
        /// @param context The request context.
        void objectAdded(const ObjectInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was added.
        /// @param info The details of the new object.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> objectAddedAsync(const ObjectInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was added.
        /// @param info The details of the new object.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> objectAddedAsync(const ObjectInfo& info, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_objectAdded(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ObjectInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that a well-known object was updated.
        /// @param info The details of the updated object.
        /// @param context The request context.
        void objectUpdated(const ObjectInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was updated.
        /// @param info The details of the updated object.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> objectUpdatedAsync(const ObjectInfo& info, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was updated.
        /// @param info The details of the updated object.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> objectUpdatedAsync(const ObjectInfo& info, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_objectUpdated(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ObjectInfo&, const Ice::Context&) const;
 
        /// Notifies the observer that a well-known object was removed.
        /// @param id The identity of the removed object.
        /// @param context The request context.
        void objectRemoved(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was removed.
        /// @param id The identity of the removed object.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> objectRemovedAsync(const ::Ice::Identity& id, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Notifies the observer that a well-known object was removed.
        /// @param id The identity of the removed object.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> objectRemovedAsync(const ::Ice::Identity& id, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_objectRemoved(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Identity&, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::ObjectObserver"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static ObjectObserverPrx _fromReference(IceInternal::ReferencePtr ref) { return ObjectObserverPrx{std::move(ref)}; }
 
    protected:
        /// @private
        ObjectObserverPrx() = default;
 
        /// @private
        explicit ObjectObserverPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
    };
 
    /// Represents an administrative session between an admin tool and an IceGrid registry.
    /// @see Registry
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdminSessionPrx : public Ice::Proxy<AdminSessionPrx, ::Glacier2::SessionPrx>
    {
    public:
#if defined(__GNUC__) && !defined(__clang__)
#   pragma GCC diagnostic push
#   pragma GCC diagnostic ignored "-Wextra" // initialize all virtual bases in correct order
#endif
 
        /// Constructs a proxy from a Communicator and a proxy string.
        /// @param communicator The communicator of the new proxy.
        /// @param proxyString The proxy string to parse.
        AdminSessionPrx(const Ice::CommunicatorPtr& communicator, std::string_view proxyString) : Ice::ObjectPrx{communicator, proxyString} {} // NOLINT(modernize-use-equals-default)
 
        /// Copy constructor. Constructs with a copy of the contents of @p other.
        /// @param other The proxy to copy from.
        AdminSessionPrx(const AdminSessionPrx& other) noexcept : Ice::ObjectPrx{other} {} // NOLINT(modernize-use-equals-default)
 
        /// Move constructor. Constructs a proxy with the contents of @p other using move semantics.
        /// @param other The proxy to move from.
        AdminSessionPrx(AdminSessionPrx&& other) noexcept : Ice::ObjectPrx{std::move(other)} {} // NOLINT(modernize-use-equals-default)
 
        ~AdminSessionPrx() override;
 
        /// Copy assignment operator. Replaces the contents of this proxy with a copy of the contents of @p rhs.
        /// @param rhs The proxy to copy from.
        /// @return A reference to this proxy.
        AdminSessionPrx& operator=(const AdminSessionPrx& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(rhs);
            }
            return *this;
        }
 
        /// Move assignment operator. Replaces the contents of this proxy with the contents of @p rhs using move semantics.
        /// @param rhs The proxy to move from.
        AdminSessionPrx& operator=(AdminSessionPrx&& rhs) noexcept
        {
            if (this != &rhs)
            {
                Ice::ObjectPrx::operator=(std::move(rhs));
            }
            return *this;
        }
 
        /// Keeps the session alive.
        /// @param context The request context.
        [[deprecated("As of Ice 3.8, there is no need to call this operation, and its implementation does nothing.")]] void keepAlive(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Keeps the session alive.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[deprecated("As of Ice 3.8, there is no need to call this operation, and its implementation does nothing.")]] [[nodiscard]] std::future<void> keepAliveAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Keeps the session alive.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        [[deprecated("As of Ice 3.8, there is no need to call this operation, and its implementation does nothing.")]] std::function<void()> keepAliveAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_keepAlive(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets a proxy to the IceGrid admin object. The admin object returned by this operation can only be accessed
        /// by the session.
        /// @param context The request context.
        /// @return A proxy to the IceGrid admin object. This proxy is never null.
        std::optional<AdminPrx> getAdmin(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a proxy to the IceGrid admin object. The admin object returned by this operation can only be accessed
        /// by the session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A proxy to the IceGrid admin object. This proxy is never null.
        [[nodiscard]] std::future<std::optional<AdminPrx>> getAdminAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a proxy to the IceGrid admin object. The admin object returned by this operation can only be accessed
        /// by the session.
        /// @param response The response callback. It accepts:
        /// - A proxy to the IceGrid admin object. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAdminAsync(std::function<void(std::optional<::IceGrid::AdminPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAdmin(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<AdminPrx>>>&, const Ice::Context&) const;
 
        /// Gets a "template" proxy for admin callback objects. An Admin client uses this proxy to set the category of
        /// its callback objects, and the published endpoints of the object adapter hosting the admin callback objects.
        /// @param context The request context.
        /// @return A template proxy. The returned proxy is null when the Admin session was established using Glacier2.
        std::optional<Ice::ObjectPrx> getAdminCallbackTemplate(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets a "template" proxy for admin callback objects. An Admin client uses this proxy to set the category of
        /// its callback objects, and the published endpoints of the object adapter hosting the admin callback objects.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - A template proxy. The returned proxy is null when the Admin session was established using Glacier2.
        [[nodiscard]] std::future<std::optional<Ice::ObjectPrx>> getAdminCallbackTemplateAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets a "template" proxy for admin callback objects. An Admin client uses this proxy to set the category of
        /// its callback objects, and the published endpoints of the object adapter hosting the admin callback objects.
        /// @param response The response callback. It accepts:
        /// - A template proxy. The returned proxy is null when the Admin session was established using Glacier2.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getAdminCallbackTemplateAsync(std::function<void(std::optional<Ice::ObjectPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getAdminCallbackTemplate(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<Ice::ObjectPrx>>>&, const Ice::Context&) const;
 
        /// Sets the observer proxies that receive notifications when the state of the registry or nodes changes.
        /// @param registryObs The registry observer.
        /// @param nodeObs The node observer.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param context The request context.
        /// @throws IceGrid::ObserverAlreadyRegisteredException Thrown when an observer is already registered with this registry.
        void setObservers(const std::optional<RegistryObserverPrx>& registryObs, const std::optional<NodeObserverPrx>& nodeObs, const std::optional<ApplicationObserverPrx>& appObs, const std::optional<AdapterObserverPrx>& adptObs, const std::optional<ObjectObserverPrx>& objObs, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sets the observer proxies that receive notifications when the state of the registry or nodes changes.
        /// @param registryObs The registry observer.
        /// @param nodeObs The node observer.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> setObserversAsync(const std::optional<RegistryObserverPrx>& registryObs, const std::optional<NodeObserverPrx>& nodeObs, const std::optional<ApplicationObserverPrx>& appObs, const std::optional<AdapterObserverPrx>& adptObs, const std::optional<ObjectObserverPrx>& objObs, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sets the observer proxies that receive notifications when the state of the registry or nodes changes.
        /// @param registryObs The registry observer.
        /// @param nodeObs The node observer.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> setObserversAsync(const std::optional<RegistryObserverPrx>& registryObs, const std::optional<NodeObserverPrx>& nodeObs, const std::optional<ApplicationObserverPrx>& appObs, const std::optional<AdapterObserverPrx>& adptObs, const std::optional<ObjectObserverPrx>& objObs, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_setObservers(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const std::optional<RegistryObserverPrx>&, const std::optional<NodeObserverPrx>&, const std::optional<ApplicationObserverPrx>&, const std::optional<AdapterObserverPrx>&, const std::optional<ObjectObserverPrx>&, const Ice::Context&) const;
 
        /// Sets the observer identities that receive notifications when the state of the registry or nodes changes.
        /// This operation should be used by clients that are using a bidirectional connection to communicate with the
        /// session.
        /// @param registryObs The registry observer identity.
        /// @param nodeObs The node observer identity.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param context The request context.
        /// @throws IceGrid::ObserverAlreadyRegisteredException Thrown when an observer is already registered with this registry.
        void setObserversByIdentity(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sets the observer identities that receive notifications when the state of the registry or nodes changes.
        /// This operation should be used by clients that are using a bidirectional connection to communicate with the
        /// session.
        /// @param registryObs The registry observer identity.
        /// @param nodeObs The node observer identity.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> setObserversByIdentityAsync(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Sets the observer identities that receive notifications when the state of the registry or nodes changes.
        /// This operation should be used by clients that are using a bidirectional connection to communicate with the
        /// session.
        /// @param registryObs The registry observer identity.
        /// @param nodeObs The node observer identity.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> setObserversByIdentityAsync(const ::Ice::Identity& registryObs, const ::Ice::Identity& nodeObs, const ::Ice::Identity& appObs, const ::Ice::Identity& adptObs, const ::Ice::Identity& objObs, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_setObserversByIdentity(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const ::Ice::Identity&, const Ice::Context&) const;
 
        /// Acquires an exclusive lock to start updating the registry applications.
        /// @param context The request context.
        /// @return The current serial.
        /// @throws IceGrid::AccessDeniedException Thrown when the exclusive lock can't be acquired. This might happen if the
        /// lock is currently acquired by another session.
        std::int32_t startUpdate(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Acquires an exclusive lock to start updating the registry applications.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The current serial.
        [[nodiscard]] std::future<std::int32_t> startUpdateAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Acquires an exclusive lock to start updating the registry applications.
        /// @param response The response callback. It accepts:
        /// - The current serial.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> startUpdateAsync(std::function<void(std::int32_t)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_startUpdate(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::int32_t>>&, const Ice::Context&) const;
 
        /// Finishes updating the registry and releases the exclusive lock.
        /// @param context The request context.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock.
        void finishUpdate(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Finishes updating the registry and releases the exclusive lock.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes.
        [[nodiscard]] std::future<void> finishUpdateAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Finishes updating the registry and releases the exclusive lock.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> finishUpdateAsync(std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_finishUpdate(const std::shared_ptr<IceInternal::OutgoingAsyncT<void>>&, const Ice::Context&) const;
 
        /// Gets the name of the registry replica hosting this session.
        /// @param context The request context.
        /// @return The replica name of the registry.
        std::string getReplicaName(const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Gets the name of the registry replica hosting this session.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - The replica name of the registry.
        [[nodiscard]] std::future<std::string> getReplicaNameAsync(const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Gets the name of the registry replica hosting this session.
        /// @param response The response callback. It accepts:
        /// - The replica name of the registry.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> getReplicaNameAsync(std::function<void(std::string)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_getReplicaName(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::string>>&, const Ice::Context&) const;
 
        /// Opens a server log file for reading.
        /// @param id The server ID.
        /// @param path The path of the log file. A log file can be opened only if it's declared in the server or
        /// service deployment descriptor.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        std::optional<FileIteratorPrx> openServerLog(std::string_view id, std::string_view path, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a server log file for reading.
        /// @param id The server ID.
        /// @param path The path of the log file. A log file can be opened only if it's declared in the server or
        /// service deployment descriptor.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openServerLogAsync(std::string_view id, std::string_view path, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a server log file for reading.
        /// @param id The server ID.
        /// @param path The path of the log file. A log file can be opened only if it's declared in the server or
        /// service deployment descriptor.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openServerLogAsync(std::string_view id, std::string_view path, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openServerLog(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a server stderr file for reading.
        /// @param id The server ID.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        std::optional<FileIteratorPrx> openServerStdErr(std::string_view id, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a server stderr file for reading.
        /// @param id The server ID.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openServerStdErrAsync(std::string_view id, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a server stderr file for reading.
        /// @param id The server ID.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openServerStdErrAsync(std::string_view id, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openServerStdErr(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a server stdout file for reading.
        /// @param id The server id.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        std::optional<FileIteratorPrx> openServerStdOut(std::string_view id, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a server stdout file for reading.
        /// @param id The server id.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openServerStdOutAsync(std::string_view id, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a server stdout file for reading.
        /// @param id The server id.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openServerStdOutAsync(std::string_view id, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openServerStdOut(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a node stderr file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        std::optional<FileIteratorPrx> openNodeStdErr(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a node stderr file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openNodeStdErrAsync(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a node stderr file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openNodeStdErrAsync(std::string_view name, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openNodeStdErr(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a node stdout file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        std::optional<FileIteratorPrx> openNodeStdOut(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a node stdout file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openNodeStdOutAsync(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a node stdout file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openNodeStdOutAsync(std::string_view name, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openNodeStdOut(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a registry stderr file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        std::optional<FileIteratorPrx> openRegistryStdErr(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a registry stderr file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openRegistryStdErrAsync(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a registry stderr file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openRegistryStdErrAsync(std::string_view name, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openRegistryStdErr(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Opens a registry stdout file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        std::optional<FileIteratorPrx> openRegistryStdOut(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const; // NOLINT(modernize-use-nodiscard)
 
        /// Opens a registry stdout file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param context The request context.
        /// @return A future that becomes available when the invocation completes. This future holds:
        /// - An iterator to read the file. This proxy is never null.
        [[nodiscard]] std::future<std::optional<FileIteratorPrx>> openRegistryStdOutAsync(std::string_view name, std::int32_t count, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// Opens a registry stdout file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param response The response callback. It accepts:
        /// - An iterator to read the file. This proxy is never null.
        /// @param exception The exception callback.
        /// @param sent The sent callback.
        /// @param context The request context.
        /// @return A function that can be called to cancel the invocation locally.
        // NOLINTNEXTLINE(modernize-use-nodiscard)
        std::function<void()> openRegistryStdOutAsync(std::string_view name, std::int32_t count, std::function<void(std::optional<::IceGrid::FileIteratorPrx>)> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
        /// @private
        void _iceI_openRegistryStdOut(const std::shared_ptr<IceInternal::OutgoingAsyncT<std::optional<FileIteratorPrx>>>&, std::string_view, std::int32_t, const Ice::Context&) const;
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::AdminSession"`.
        static const char* ice_staticId() noexcept;
 
        /// @private
        static AdminSessionPrx _fromReference(IceInternal::ReferencePtr ref) { return AdminSessionPrx{std::move(ref)}; }
 
    protected:
        /// @private
        AdminSessionPrx() = default;
 
        /// @private
        explicit AdminSessionPrx(IceInternal::ReferencePtr&& ref) : Ice::ObjectPrx{std::move(ref)}
        {
        }
 
#if defined(__GNUC__) && !defined(__clang__)
#   pragma GCC diagnostic pop
#endif
    };
}
 
namespace IceGrid
{
    /// Information about an Ice well-known object.
    /// @headerfile IceGrid/IceGrid.h
    struct ObjectInfo
    {
        /// The proxy of the object.
        std::optional<Ice::ObjectPrx> proxy;
 
        /// The type of the object.
        std::string type;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::optional<Ice::ObjectPrx>&, const std::string&> ice_tuple() const
        {
            return std::tie(proxy, type);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ObjectInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ObjectInfo& value);
 
    /// Information about an adapter registered with the IceGrid registry.
    /// @headerfile IceGrid/IceGrid.h
    struct AdapterInfo
    {
        /// The ID of the adapter.
        std::string id;
 
        /// A dummy direct proxy that contains the adapter endpoints.
        std::optional<Ice::ObjectPrx> proxy;
 
        /// The replica group ID of the object adapter, or empty if the adapter doesn't belong to a replica group.
        std::string replicaGroupId;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::optional<Ice::ObjectPrx>&, const std::string&> ice_tuple() const
        {
            return std::tie(id, proxy, replicaGroupId);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an AdapterInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const AdapterInfo& value);
 
    /// Information about a server managed by an IceGrid node.
    /// @headerfile IceGrid/IceGrid.h
    struct ServerInfo
    {
        /// The application to which this server belongs.
        std::string application;
 
        /// The application UUID.
        std::string uuid;
 
        /// The application revision.
        std::int32_t revision;
 
        /// The IceGrid node where this server is deployed.
        std::string node;
 
        /// The server descriptor.
        ::IceGrid::ServerDescriptorPtr descriptor;
 
        /// The ID of the session which allocated the server.
        std::string sessionId;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&, const std::int32_t&, const std::string&, const ::IceGrid::ServerDescriptorPtr&, const std::string&> ice_tuple() const
        {
            return std::tie(application, uuid, revision, node, descriptor, sessionId);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a ServerInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ServerInfo& value);
 
    /// Information about an IceGrid node.
    /// @headerfile IceGrid/IceGrid.h
    struct NodeInfo
    {
        /// The name of the node.
        std::string name;
 
        /// The operating system name.
        std::string os;
 
        /// The network name of the host running this node.
        std::string hostname;
 
        /// The operation system release level.
        std::string release;
 
        /// The operation system version.
        std::string version;
 
        /// The machine hardware type.
        std::string machine;
 
        /// The number of processor threads on the node.
        /// For example, nProcessors is 8 on a computer with a single quad-core processor and two threads per core.
        std::int32_t nProcessors;
 
        /// The path to the node data directory.
        std::string dataDir;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const std::string&, const std::int32_t&, const std::string&> ice_tuple() const
        {
            return std::tie(name, os, hostname, release, version, machine, nProcessors, dataDir);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a NodeInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const NodeInfo& value);
 
    /// Information about an IceGrid registry replica.
    /// @headerfile IceGrid/IceGrid.h
    struct RegistryInfo
    {
        /// The name of the registry.
        std::string name;
 
        /// The network name of the host running this registry.
        std::string hostname;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::string&> ice_tuple() const
        {
            return std::tie(name, hostname);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a RegistryInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const RegistryInfo& value);
 
    /// Information about the load of a node.
    /// @headerfile IceGrid/IceGrid.h
    struct LoadInfo
    {
        /// The load average over the past minute.
        float avg1;
 
        /// The load average over the past 5 minutes.
        float avg5;
 
        /// The load average over the past 15 minutes.
        float avg15;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const float&, const float&, const float&> ice_tuple() const
        {
            return std::tie(avg1, avg5, avg15);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a LoadInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const LoadInfo& value);
 
    /// Information about an IceGrid application.
    /// @headerfile IceGrid/IceGrid.h
    struct ApplicationInfo
    {
        /// Unique application identifier.
        std::string uuid;
 
        /// The creation time.
        std::int64_t createTime;
 
        /// The user who created the application.
        std::string createUser;
 
        /// The last update time.
        std::int64_t updateTime;
 
        /// The user who updated the application.
        std::string updateUser;
 
        /// The application revision number.
        std::int32_t revision;
 
        /// The application descriptor.
        ::IceGrid::ApplicationDescriptor descriptor;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::int64_t&, const std::string&, const std::int64_t&, const std::string&, const std::int32_t&, const ::IceGrid::ApplicationDescriptor&> ice_tuple() const
        {
            return std::tie(uuid, createTime, createUser, updateTime, updateUser, revision, descriptor);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ApplicationInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ApplicationInfo& value);
 
    /// Information about updates to an IceGrid application.
    /// @headerfile IceGrid/IceGrid.h
    struct ApplicationUpdateInfo
    {
        /// The update time.
        std::int64_t updateTime;
 
        /// The user who updated the application.
        std::string updateUser;
 
        /// The application revision number.
        std::int32_t revision;
 
        /// The update descriptor.
        ::IceGrid::ApplicationUpdateDescriptor descriptor;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::int64_t&, const std::string&, const std::int32_t&, const ::IceGrid::ApplicationUpdateDescriptor&> ice_tuple() const
        {
            return std::tie(updateTime, updateUser, revision, descriptor);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an ApplicationUpdateInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ApplicationUpdateInfo& value);
 
    /// Dynamic information about the state of a server.
    /// @headerfile IceGrid/IceGrid.h
    struct ServerDynamicInfo
    {
        /// The ID of the server.
        std::string id;
 
        /// The state of the server.
        ::IceGrid::ServerState state;
 
        /// The process ID of the server.
        std::int32_t pid;
 
        /// Indicates whether the server is enabled.
        bool enabled;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const ::IceGrid::ServerState&, const std::int32_t&, const bool&> ice_tuple() const
        {
            return std::tie(id, state, pid, enabled);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a ServerDynamicInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const ServerDynamicInfo& value);
 
    /// Dynamic information about the state of an adapter.
    /// @headerfile IceGrid/IceGrid.h
    struct AdapterDynamicInfo
    {
        /// The id of the adapter.
        std::string id;
 
        /// The direct proxy containing the adapter endpoints. This proxy is never null.
        std::optional<Ice::ObjectPrx> proxy;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const std::string&, const std::optional<Ice::ObjectPrx>&> ice_tuple() const
        {
            return std::tie(id, proxy);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of an AdapterDynamicInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const AdapterDynamicInfo& value);
 
    /// Dynamic information about the state of a node.
    /// @headerfile IceGrid/IceGrid.h
    struct NodeDynamicInfo
    {
        /// Some static information about the node.
        ::IceGrid::NodeInfo info;
 
        /// The dynamic information of the servers deployed on this node.
        ::IceGrid::ServerDynamicInfoSeq servers;
 
        /// The dynamic information of the adapters deployed on this node.
        ::IceGrid::AdapterDynamicInfoSeq adapters;
 
        /// Creates a tuple with all the fields of this struct.
        /// @return A tuple with all the fields of this struct.
        [[nodiscard]] std::tuple<const ::IceGrid::NodeInfo&, const ::IceGrid::ServerDynamicInfoSeq&, const ::IceGrid::AdapterDynamicInfoSeq&> ice_tuple() const
        {
            return std::tie(info, servers, adapters);
        }
 
        /// Outputs the name and value of each field of this instance to the stream.
        /// @param os The output stream.
        ICEGRID_API void ice_printFields(std::ostream& os) const;
    };
 
    /// Outputs the description of a NodeDynamicInfo to a stream, including all its fields.
    /// @param os The output stream.
    /// @param value The instance to output.
    /// @return The output stream.
    ICEGRID_API std::ostream& operator<<(std::ostream& os, const NodeDynamicInfo& value);
 
    /// @cond INTERNAL
    using Ice::Tuple::operator<;
    using Ice::Tuple::operator<=;
    using Ice::Tuple::operator>;
    using Ice::Tuple::operator>=;
    using Ice::Tuple::operator==;
    using Ice::Tuple::operator!=;
    /// @endcond
}
 
namespace IceGrid
{
    /// Provides administrative access to an IceGrid deployment.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API Admin : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = AdminPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Adds an application to IceGrid.
        /// @param descriptor The application descriptor.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void addApplication(ApplicationDescriptor descriptor, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_addApplication(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor.
        /// @param descriptor The new application descriptor.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void syncApplication(ApplicationDescriptor descriptor, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_syncApplication(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Updates a deployed application.
        /// @param descriptor The update descriptor.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void updateApplication(ApplicationUpdateDescriptor descriptor, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_updateApplication(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Synchronizes a deployed application. This operation replaces the current descriptor with a new descriptor
        /// only if no server restarts are necessary for the update of the application. If some servers need to be
        /// restarted, the synchronization is rejected with a DeploymentException.
        /// @param descriptor The application descriptor.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void syncApplicationWithoutRestart(ApplicationDescriptor descriptor, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_syncApplicationWithoutRestart(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Updates a deployed application. This operation succeeds only when no server restarts are necessary for the
        /// update of the application. If some servers need to be restarted, the synchronization is rejected with a
        /// DeploymentException.
        /// @param descriptor The update descriptor.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void updateApplicationWithoutRestart(ApplicationUpdateDescriptor descriptor, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_updateApplicationWithoutRestart(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes an application from IceGrid.
        /// @param name The application name.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void removeApplication(std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_removeApplication(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Instantiates a server template.
        /// @param application The application name.
        /// @param node The name of the node where the server will be deployed.
        /// @param desc The descriptor of the server instance to deploy.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock or when another
        /// session is holding the lock.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void instantiateServer(std::string application, std::string node, ServerInstanceDescriptor desc, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_instantiateServer(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets an application descriptor.
        /// @param name The application name.
        /// @param current The Current object of the incoming request.
        /// @return The application descriptor.
        /// @throws IceGrid::ApplicationNotExistException Thrown when the application doesn't exist.
        [[nodiscard]] virtual ApplicationInfo getApplicationInfo(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getApplicationInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the default application descriptor.
        /// @param current The Current object of the incoming request.
        /// @return The default application descriptor.
        /// @throws IceGrid::DeploymentException Thrown when the default application descriptor is invalid or unreachable.
        [[nodiscard]] virtual ApplicationDescriptor getDefaultApplicationDescriptor(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getDefaultApplicationDescriptor(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets all the IceGrid applications currently registered.
        /// @param current The Current object of the incoming request.
        /// @return The application names.
        [[nodiscard]] virtual ::Ice::StringSeq getAllApplicationNames(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllApplicationNames(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets information about a server.
        /// @param id The server ID.
        /// @param current The Current object of the incoming request.
        /// @return The server information.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        [[nodiscard]] virtual ServerInfo getServerInfo(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getServerInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the state of a server.
        /// @param id The server ID.
        /// @param current The Current object of the incoming request.
        /// @return The server state.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        [[nodiscard]] virtual ServerState getServerState(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getServerState(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the system process ID of a server. The process ID is operating system dependent.
        /// @param id The server ID.
        /// @param current The Current object of the incoming request.
        /// @return The process ID.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        [[nodiscard]] virtual std::int32_t getServerPid(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getServerPid(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the category for server admin objects. You can manufacture a server admin proxy from the admin proxy by
        /// changing its identity: use the server ID as name and the returned category as category.
        /// @param current The Current object of the incoming request.
        /// @return The category for server admin objects.
        [[nodiscard]] virtual std::string getServerAdminCategory(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getServerAdminCategory(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets a proxy to the admin object of a server.
        /// @param id The server ID.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the admin object of the server. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        [[nodiscard]] virtual std::optional<Ice::ObjectPrx> getServerAdmin(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getServerAdmin(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Enables or disables a server. A disabled server can't be started on demand or administratively. The enable
        /// state of the server is not persistent: if the node is shut down and restarted, the server will be enabled by
        /// default.
        /// @param id The server ID.
        /// @param enabled `true` to enable the server, `false` to disable it.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        virtual void enableServer(std::string id, bool enabled, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_enableServer(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Checks if the server is enabled or disabled.
        /// @param id The server ID.
        /// @param current The Current object of the incoming request.
        /// @return `true` if the server is enabled, `false` otherwise.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        [[nodiscard]] virtual bool isServerEnabled(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_isServerEnabled(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Starts a server and waits for its activation.
        /// @param id The server id.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        /// @throws IceGrid::ServerStartException Thrown when the server startup failed.
        virtual void startServerAsync(std::string id, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_startServer(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Stops a server.
        /// @param id The server ID.
        /// @param response The response callback.
        /// @param exception The exception callback.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        /// @throws IceGrid::ServerStopException Thrown when the server stop failed.
        virtual void stopServerAsync(std::string id, std::function<void()> response, std::function<void(std::exception_ptr)> exception, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_stopServer(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Sends a signal to a server.
        /// @param id The server ID.
        /// @param signal The signal, for example SIGTERM or 15.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::BadSignalException Thrown when the signal is not recognized by the target server.
        /// @throws IceGrid::DeploymentException Thrown when the deployment of the server failed.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        virtual void sendSignal(std::string id, std::string signal, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_sendSignal(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the IDs of all the servers registered with IceGrid.
        /// @param current The Current object of the incoming request.
        /// @return The server IDs.
        [[nodiscard]] virtual ::Ice::StringSeq getAllServerIds(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllServerIds(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets adapter information for the replica group or adapter with the given ID.
        /// @param id The adapter or replica group ID.
        /// @param current The Current object of the incoming request.
        /// @return A sequence of AdapterInfo. If @p id refers to an adapter, this sequence contains a single element.
        /// If @p id refers to a replica group, this sequence contains adapter information for each member of the
        /// replica group.
        /// @throws IceGrid::AdapterNotExistException Thrown when the adapter or replica group doesn't exist.
        [[nodiscard]] virtual AdapterInfoSeq getAdapterInfo(std::string id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAdapterInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Removes the adapter with the given ID.
        /// @param id The adapter ID.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AdapterNotExistException Thrown when the adapter doesn't exist.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        virtual void removeAdapter(std::string id, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_removeAdapter(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the IDs of all adapters registered with IceGrid.
        /// @param current The Current object of the incoming request.
        /// @return The adapter IDs.
        [[nodiscard]] virtual ::Ice::StringSeq getAllAdapterIds(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllAdapterIds(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Adds an object to the object registry. IceGrid gets the object type by calling `ice_id` on @p obj. The
        /// object must be reachable.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be added.
        /// @throws IceGrid::ObjectExistsException Thrown when the object is already registered.
        virtual void addObject(std::optional<Ice::ObjectPrx> obj, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_addObject(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Updates an object in the object registry. Only objects added with this interface can be updated with this
        /// operation. Objects added with deployment descriptors should be updated with the deployment mechanism.
        /// @param obj A proxy to the object. This proxy is never null.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be updated.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        virtual void updateObject(std::optional<Ice::ObjectPrx> obj, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_updateObject(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Adds an object to the object registry and explicitly specifies its type.
        /// @param obj The object to be added to the registry. The proxy is never null.
        /// @param type The type name.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the application deployment failed.
        /// @throws IceGrid::ObjectExistsException Thrown when the object is already registered.
        virtual void addObjectWithType(std::optional<Ice::ObjectPrx> obj, std::string type, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_addObjectWithType(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Removes an object from the object registry. Only objects added with this interface can be removed with this
        /// operation. Objects added with deployment descriptors should be removed with the deployment mechanism.
        /// @param id The identity of the object to remove.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::DeploymentException Thrown when the object can't be removed.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        virtual void removeObject(::Ice::Identity id, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_removeObject(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the object info for the object.
        /// @param id The identity of the object.
        /// @param current The Current object of the incoming request.
        /// @return The object info.
        /// @throws IceGrid::ObjectNotRegisteredException Thrown when the object isn't registered with the registry.
        [[nodiscard]] virtual ObjectInfo getObjectInfo(::Ice::Identity id, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getObjectInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the object info of all the registered objects with a given type.
        /// @param type The type name.
        /// @param current The Current object of the incoming request.
        /// @return The object infos.
        [[nodiscard]] virtual ObjectInfoSeq getObjectInfosByType(std::string type, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getObjectInfosByType(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the object info of all the registered objects whose stringified identities match the given expression.
        /// @param expr The expression to match against the stringified identities of registered objects. The expression
        /// may contain a trailing wildcard (`*`) character.
        /// @param current The Current object of the incoming request.
        /// @return All the object infos with a stringified identity matching the given expression.
        [[nodiscard]] virtual ObjectInfoSeq getAllObjectInfos(std::string expr, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllObjectInfos(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Pings an IceGrid node to see if it is active.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @return `true` if the node ping succeeded, `false` otherwise.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        [[nodiscard]] virtual bool pingNode(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_pingNode(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the load averages of a node.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @return The node load information.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        [[nodiscard]] virtual LoadInfo getNodeLoad(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getNodeLoad(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the node information of a node.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @return The node information.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        [[nodiscard]] virtual NodeInfo getNodeInfo(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getNodeInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets a proxy to the admin object of an IceGrid node.
        /// @param name The IceGrid node name.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the IceGrid node's admin object. This proxy is never null.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        [[nodiscard]] virtual std::optional<Ice::ObjectPrx> getNodeAdmin(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getNodeAdmin(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the number of physical processor sockets in the computer where an IceGrid node is deployed.
        /// Note that this operation returns 1 on operating systems where this can't be automatically determined and
        /// where the `IceGrid.Node.ProcessorSocketCount` property for the node is not set.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @return The number of processor sockets or 1 if the number of sockets can't be determined.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        [[nodiscard]] virtual std::int32_t getNodeProcessorSocketCount(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getNodeProcessorSocketCount(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Shuts down an IceGrid node.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        virtual void shutdownNode(std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_shutdownNode(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Get the hostname of a node.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        /// @return The node hostname.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        [[nodiscard]] virtual std::string getNodeHostname(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getNodeHostname(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the names of all IceGrid nodes currently registered.
        /// @param current The Current object of the incoming request.
        /// @return The node names.
        [[nodiscard]] virtual ::Ice::StringSeq getAllNodeNames(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllNodeNames(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Pings an IceGrid registry to see if it is active.
        /// @param name The registry name.
        /// @param current The Current object of the incoming request.
        /// @return `true` if the registry ping succeeded, `false` otherwise.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        [[nodiscard]] virtual bool pingRegistry(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_pingRegistry(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets the registry information of an IceGrid registry.
        /// @param name The registry name.
        /// @param current The Current object of the incoming request.
        /// @return The registry information.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        [[nodiscard]] virtual RegistryInfo getRegistryInfo(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getRegistryInfo(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets a proxy to the admin object of an IceGrid registry.
        /// @param name The registry name.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the admin object of an IceGrid registry. This proxy is never null.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        [[nodiscard]] virtual std::optional<Ice::ObjectPrx> getRegistryAdmin(std::string name, const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getRegistryAdmin(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Shuts down an IceGrid registry.
        /// @param name The registry name.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        virtual void shutdownRegistry(std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_shutdownRegistry(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the names of all the IceGrid registries currently registered.
        /// @param current The Current object of the incoming request.
        /// @return The registry names.
        [[nodiscard]] virtual ::Ice::StringSeq getAllRegistryNames(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAllRegistryNames(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Shuts down the IceGrid registry.
        /// @param current The Current object of the incoming request.
        virtual void shutdown(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_shutdown(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::Admin"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an Admin.
    using AdminPtr = std::shared_ptr<Admin>;
 
    /// Iterates over an IceGrid log file.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API FileIterator : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = FileIteratorPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Read lines from the log file.
        /// @param size Specifies the maximum number of bytes to be received. The server will ensure that the returned
        /// message doesn't exceed the given size.
        /// @param[out] lines The lines read from the file. If there was nothing to read from the file since the last call to
        /// read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
        /// newline character should be added when writing the last line to the to the output device).
        /// @param current The Current object of the incoming request.
        /// @return `true` if EOF is encountered.
        /// @throws IceGrid::FileNotAvailableException Thrown when the implementation failed to read from the file.
        virtual bool read(std::int32_t size, ::Ice::StringSeq& lines, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_read(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Destroys the iterator.
        /// @param current The Current object of the incoming request.
        virtual void destroy(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_destroy(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::FileIterator"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a FileIterator.
    using FileIteratorPtr = std::shared_ptr<FileIterator>;
 
    /// Monitors changes to the state of the registries.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API RegistryObserver : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = RegistryObserverPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Provides the initial state of the registries to the observer.
        /// @param registries The current state of the registries.
        /// @param current The Current object of the incoming request.
        virtual void registryInit(RegistryInfoSeq registries, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_registryInit(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a registry replica came up.
        /// @param registryReplica The registry state.
        /// @param current The Current object of the incoming request.
        virtual void registryUp(RegistryInfo registryReplica, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_registryUp(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a registry replica went down.
        /// @param name The registry name.
        /// @param current The Current object of the incoming request.
        virtual void registryDown(std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_registryDown(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::RegistryObserver"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a RegistryObserver.
    using RegistryObserverPtr = std::shared_ptr<RegistryObserver>;
 
    /// Monitors changes to the state of the nodes.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API NodeObserver : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = NodeObserverPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Provides the initial state of the nodes to the observer.
        /// @param nodes The current state of the nodes.
        /// @param current The Current object of the incoming request.
        virtual void nodeInit(NodeDynamicInfoSeq nodes, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_nodeInit(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a node came up.
        /// @param node The node state.
        /// @param current The Current object of the incoming request.
        virtual void nodeUp(NodeDynamicInfo node, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_nodeUp(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a node went down.
        /// @param name The node name.
        /// @param current The Current object of the incoming request.
        virtual void nodeDown(std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_nodeDown(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that the state of a server changed.
        /// @param node The node hosting the server.
        /// @param updatedInfo The new server state.
        /// @param current The Current object of the incoming request.
        virtual void updateServer(std::string node, ServerDynamicInfo updatedInfo, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_updateServer(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that the state of an object adapter changed.
        /// @param node The node hosting the adapter.
        /// @param updatedInfo The new adapter state.
        /// @param current The Current object of the incoming request.
        virtual void updateAdapter(std::string node, AdapterDynamicInfo updatedInfo, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_updateAdapter(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::NodeObserver"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to a NodeObserver.
    using NodeObserverPtr = std::shared_ptr<NodeObserver>;
 
    /// Monitors applications.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ApplicationObserver : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = ApplicationObserverPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Provides the initial application infos to the observer.
        /// @param serial The current serial number of the registry database. This serial number allows observers to
        /// make sure that their internal state is synchronized with the registry.
        /// @param applications The applications currently registered with the registry.
        /// @param current The Current object of the incoming request.
        virtual void applicationInit(std::int32_t serial, ApplicationInfoSeq applications, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_applicationInit(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that an application was added.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the new application.
        /// @param current The Current object of the incoming request.
        virtual void applicationAdded(std::int32_t serial, ApplicationInfo desc, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_applicationAdded(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that an application was removed.
        /// @param serial The new serial number of the registry database.
        /// @param name The name of the application that was removed.
        /// @param current The Current object of the incoming request.
        virtual void applicationRemoved(std::int32_t serial, std::string name, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_applicationRemoved(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that an application was updated.
        /// @param serial The new serial number of the registry database.
        /// @param desc The descriptor of the update.
        /// @param current The Current object of the incoming request.
        virtual void applicationUpdated(std::int32_t serial, ApplicationUpdateInfo desc, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_applicationUpdated(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::ApplicationObserver"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an ApplicationObserver.
    using ApplicationObserverPtr = std::shared_ptr<ApplicationObserver>;
 
    /// Monitors dynamically-registered object adapters.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdapterObserver : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = AdapterObserverPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Provides the initial list of dynamically registered adapters to the observer.
        /// @param adpts The adapters that were dynamically registered with the registry.
        /// @param current The Current object of the incoming request.
        virtual void adapterInit(AdapterInfoSeq adpts, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterInit(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a dynamically-registered adapter was added.
        /// @param info The details of the new adapter.
        /// @param current The Current object of the incoming request.
        virtual void adapterAdded(AdapterInfo info, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterAdded(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// @param info The details of the updated adapter.
        /// @param current The Current object of the incoming request.
        virtual void adapterUpdated(AdapterInfo info, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterUpdated(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a dynamically-registered adapter was removed.
        /// @param id The ID of the removed adapter.
        /// @param current The Current object of the incoming request.
        virtual void adapterRemoved(std::string id, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_adapterRemoved(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::AdapterObserver"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AdapterObserver.
    using AdapterObserverPtr = std::shared_ptr<AdapterObserver>;
 
    /// Monitors well-known objects that are added, updated or removed using AdminPrx.
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API ObjectObserver : public virtual Ice::Object
    {
    public:
        /// The associated proxy type.
        using ProxyType = ObjectObserverPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Provides the initial list of well-known objects to the observer.
        /// @param objects The well-known objects registered using ::IceGrid::AdminPrx.
        /// @param current The Current object of the incoming request.
        virtual void objectInit(ObjectInfoSeq objects, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_objectInit(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a well-known object was added.
        /// @param info The details of the new object.
        /// @param current The Current object of the incoming request.
        virtual void objectAdded(ObjectInfo info, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_objectAdded(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a well-known object was updated.
        /// @param info The details of the updated object.
        /// @param current The Current object of the incoming request.
        virtual void objectUpdated(ObjectInfo info, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_objectUpdated(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Notifies the observer that a well-known object was removed.
        /// @param id The identity of the removed object.
        /// @param current The Current object of the incoming request.
        virtual void objectRemoved(::Ice::Identity id, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_objectRemoved(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::ObjectObserver"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an ObjectObserver.
    using ObjectObserverPtr = std::shared_ptr<ObjectObserver>;
 
    /// Represents an administrative session between an admin tool and an IceGrid registry.
    /// @see Registry
    /// @headerfile IceGrid/IceGrid.h
    class ICEGRID_API AdminSession : public virtual ::Glacier2::Session
    {
    public:
        /// The associated proxy type.
        using ProxyType = AdminSessionPrx;
 
        /// Dispatches an incoming request to one of the member functions of this generated class, based on the operation name carried by the request.
        /// @param request The incoming request.
        /// @param sendResponse The callback to send the response.
        void dispatch(Ice::IncomingRequest& request, std::function<void(Ice::OutgoingResponse)> sendResponse) override;
 
        [[nodiscard]] std::vector<std::string> ice_ids(const Ice::Current& current) const override;
 
        [[nodiscard]] std::string ice_id(const Ice::Current& current) const override;
 
        /// Keeps the session alive.
        /// @param current The Current object of the incoming request.
        virtual void keepAlive(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_keepAlive(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets a proxy to the IceGrid admin object. The admin object returned by this operation can only be accessed
        /// by the session.
        /// @param current The Current object of the incoming request.
        /// @return A proxy to the IceGrid admin object. This proxy is never null.
        [[nodiscard]] virtual std::optional<AdminPrx> getAdmin(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAdmin(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Gets a "template" proxy for admin callback objects. An Admin client uses this proxy to set the category of
        /// its callback objects, and the published endpoints of the object adapter hosting the admin callback objects.
        /// @param current The Current object of the incoming request.
        /// @return A template proxy. The returned proxy is null when the Admin session was established using Glacier2.
        [[nodiscard]] virtual std::optional<Ice::ObjectPrx> getAdminCallbackTemplate(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getAdminCallbackTemplate(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Sets the observer proxies that receive notifications when the state of the registry or nodes changes.
        /// @param registryObs The registry observer.
        /// @param nodeObs The node observer.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::ObserverAlreadyRegisteredException Thrown when an observer is already registered with this registry.
        virtual void setObservers(std::optional<RegistryObserverPrx> registryObs, std::optional<NodeObserverPrx> nodeObs, std::optional<ApplicationObserverPrx> appObs, std::optional<AdapterObserverPrx> adptObs, std::optional<ObjectObserverPrx> objObs, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_setObservers(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Sets the observer identities that receive notifications when the state of the registry or nodes changes.
        /// This operation should be used by clients that are using a bidirectional connection to communicate with the
        /// session.
        /// @param registryObs The registry observer identity.
        /// @param nodeObs The node observer identity.
        /// @param appObs The application observer.
        /// @param adptObs The adapter observer.
        /// @param objObs The object observer.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::ObserverAlreadyRegisteredException Thrown when an observer is already registered with this registry.
        virtual void setObserversByIdentity(::Ice::Identity registryObs, ::Ice::Identity nodeObs, ::Ice::Identity appObs, ::Ice::Identity adptObs, ::Ice::Identity objObs, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_setObserversByIdentity(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Acquires an exclusive lock to start updating the registry applications.
        /// @param current The Current object of the incoming request.
        /// @return The current serial.
        /// @throws IceGrid::AccessDeniedException Thrown when the exclusive lock can't be acquired. This might happen if the
        /// lock is currently acquired by another session.
        virtual std::int32_t startUpdate(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_startUpdate(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Finishes updating the registry and releases the exclusive lock.
        /// @param current The Current object of the incoming request.
        /// @throws IceGrid::AccessDeniedException Thrown when the session doesn't hold the exclusive lock.
        virtual void finishUpdate(const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_finishUpdate(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the name of the registry replica hosting this session.
        /// @param current The Current object of the incoming request.
        /// @return The replica name of the registry.
        [[nodiscard]] virtual std::string getReplicaName(const Ice::Current& current) const = 0;
 
        /// @private
        void _iceD_getReplicaName(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>) const;
 
        /// Opens a server log file for reading.
        /// @param id The server ID.
        /// @param path The path of the log file. A log file can be opened only if it's declared in the server or
        /// service deployment descriptor.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        virtual std::optional<FileIteratorPrx> openServerLog(std::string id, std::string path, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openServerLog(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a server stderr file for reading.
        /// @param id The server ID.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        virtual std::optional<FileIteratorPrx> openServerStdErr(std::string id, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openServerStdErr(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a server stdout file for reading.
        /// @param id The server id.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::DeploymentException Thrown when the server couldn't be deployed on the node.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        /// @throws IceGrid::ServerNotExistException Thrown when the server doesn't exist.
        virtual std::optional<FileIteratorPrx> openServerStdOut(std::string id, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openServerStdOut(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a node stderr file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        virtual std::optional<FileIteratorPrx> openNodeStdErr(std::string name, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openNodeStdErr(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a node stdout file for reading.
        /// @param name The node name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::NodeNotExistException Thrown when the node doesn't exist.
        /// @throws IceGrid::NodeUnreachableException Thrown when the node is unreachable.
        virtual std::optional<FileIteratorPrx> openNodeStdOut(std::string name, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openNodeStdOut(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a registry stderr file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        virtual std::optional<FileIteratorPrx> openRegistryStdErr(std::string name, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openRegistryStdErr(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Opens a registry stdout file for reading.
        /// @param name The registry name.
        /// @param count Specifies where to start reading the file. If negative, the file is read from the beginning.
        /// Otherwise, the file is read from the last @p count lines.
        /// @param current The Current object of the incoming request.
        /// @return An iterator to read the file. This proxy is never null.
        /// @throws IceGrid::FileNotAvailableException Thrown when the file can't be read.
        /// @throws IceGrid::RegistryNotExistException Thrown when the registry doesn't exist.
        /// @throws IceGrid::RegistryUnreachableException Thrown when the registry is unreachable.
        virtual std::optional<FileIteratorPrx> openRegistryStdOut(std::string name, std::int32_t count, const Ice::Current& current) = 0;
 
        /// @private
        void _iceD_openRegistryStdOut(Ice::IncomingRequest&, std::function<void(Ice::OutgoingResponse)>);
 
        /// Gets the type ID of the associated Slice interface.
        /// @return The string `"::IceGrid::AdminSession"`.
        static const char* ice_staticId() noexcept;
    };
 
    /// A shared pointer to an AdminSession.
    using AdminSessionPtr = std::shared_ptr<AdminSession>;
}
 
namespace Ice
{
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ServerState>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryEnum;
        static constexpr int minValue = 0;
        static constexpr int maxValue = 6;
        static constexpr int minWireSize = 1;
        static constexpr bool fixedLength = false;
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ObjectInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 3;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ObjectInfo>
    {
        /// Unmarshals a ::IceGrid::ObjectInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::ObjectInfo& v)
        {
            istr->readAll(v.proxy, v.type);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::AdapterInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 4;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::AdapterInfo>
    {
        /// Unmarshals a ::IceGrid::AdapterInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::AdapterInfo& v)
        {
            istr->readAll(v.id, v.proxy, v.replicaGroupId);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ServerInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 9;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ServerInfo>
    {
        /// Unmarshals a ::IceGrid::ServerInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::ServerInfo& v)
        {
            istr->readAll(v.application, v.uuid, v.revision, v.node, v.descriptor, v.sessionId);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::NodeInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 11;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::NodeInfo>
    {
        /// Unmarshals a ::IceGrid::NodeInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::NodeInfo& v)
        {
            istr->readAll(v.name, v.os, v.hostname, v.release, v.version, v.machine, v.nProcessors, v.dataDir);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::RegistryInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 2;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::RegistryInfo>
    {
        /// Unmarshals a ::IceGrid::RegistryInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::RegistryInfo& v)
        {
            istr->readAll(v.name, v.hostname);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::LoadInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 12;
        static constexpr bool fixedLength = true;
    };
 
    template<>
    struct StreamReader<::IceGrid::LoadInfo>
    {
        /// Unmarshals a ::IceGrid::LoadInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::LoadInfo& v)
        {
            istr->readAll(v.avg1, v.avg5, v.avg15);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ApplicationInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 33;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ApplicationInfo>
    {
        /// Unmarshals a ::IceGrid::ApplicationInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::ApplicationInfo& v)
        {
            istr->readAll(v.uuid, v.createTime, v.createUser, v.updateTime, v.updateUser, v.revision, v.descriptor);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ApplicationUpdateInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 28;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ApplicationUpdateInfo>
    {
        /// Unmarshals a ::IceGrid::ApplicationUpdateInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::ApplicationUpdateInfo& v)
        {
            istr->readAll(v.updateTime, v.updateUser, v.revision, v.descriptor);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::ServerDynamicInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 7;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::ServerDynamicInfo>
    {
        /// Unmarshals a ::IceGrid::ServerDynamicInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::ServerDynamicInfo& v)
        {
            istr->readAll(v.id, v.state, v.pid, v.enabled);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::AdapterDynamicInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 3;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::AdapterDynamicInfo>
    {
        /// Unmarshals a ::IceGrid::AdapterDynamicInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::AdapterDynamicInfo& v)
        {
            istr->readAll(v.id, v.proxy);
        }
    };
    /// @endcond
 
    /// @cond INTERNAL
    template<>
    struct StreamableTraits<::IceGrid::NodeDynamicInfo>
    {
        static constexpr StreamHelperCategory helper = StreamHelperCategoryStruct;
        static constexpr int minWireSize = 13;
        static constexpr bool fixedLength = false;
    };
 
    template<>
    struct StreamReader<::IceGrid::NodeDynamicInfo>
    {
        /// Unmarshals a ::IceGrid::NodeDynamicInfo from the input stream.
        static void read(InputStream* istr, ::IceGrid::NodeDynamicInfo& v)
        {
            istr->readAll(v.info, v.servers, v.adapters);
        }
    };
    /// @endcond
}
 
// NOLINTEND(modernize-concat-nested-namespaces)
 
#include <Ice/PopDisableWarnings.h>
#endif