import {Ice} from 'ice';
import '../Ice/Identity';
import '../Ice/BuiltinSequences';
import '../Ice/Properties';
import '../Ice/SliceChecksumDict';
import {Glacier2} from '../Glacier2/Session';
import {IceGrid} from '../IceGrid/Exception';
import '../IceGrid/Descriptor';

declare module './IceGrid.ns' {
  namespace IceGrid {
    type ServerStateName =
      | 'Inactive'
      | 'Activating'
      | 'ActivationTimedOut'
      | 'Active'
      | 'Deactivating'
      | 'Destroying'
      | 'Destroyed';

    /**
     * An enumeration representing the state of the server.
     */
    class ServerState<
      Name extends ServerStateName = ServerStateName
    > extends Ice.EnumBase<Name> {
      /**
       * The server is not running.
       */
      static Inactive: ServerState<'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.
       */
      static Activating: ServerState<'Activating'>;

      /**
       * The activation timed out state indicates that the server
       * activation timed out.
       */
      static ActivationTimedOut: ServerState<'ActivationTimedOut'>;

      /**
       * The server is running.
       */
      static Active: ServerState<'Active'>;

      /**
       * The server is being deactivated.
       */
      static Deactivating: ServerState<'Deactivating'>;

      /**
       * The server is being destroyed.
       */
      static Destroying: ServerState<'Destroying'>;

      /**
       * The server is destroyed.
       */
      static Destroyed: ServerState<'Destroyed'>;
    }

    /**
     * A dictionary of proxies.
     */
    type StringObjectProxyDict = Map<string, Ice.ObjectPrx | null>;
    const StringObjectProxyDict: {
      /**
       * A dictionary of proxies.
       */
      new (
        entries?: ReadonlyArray<[string, Ice.ObjectPrx | null]>,
      ): StringObjectProxyDict;
    };

    /**
     * Information about an Ice object.
     */
    class ObjectInfo implements Ice.Struct {
      constructor(proxy?: Ice.ObjectPrx | null, type?: string);

      /**
       * The proxy of the object.
       */
      proxy: Ice.ObjectPrx | null;

      /**
       * The type of the object.
       */
      type: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of object information structures.
     */
    type ObjectInfoSeq = Array<ObjectInfo>;

    /**
     * Information about an adapter registered with the IceGrid registry.
     */
    class AdapterInfo implements Ice.Struct {
      constructor(
        id?: string,
        proxy?: Ice.ObjectPrx | null,
        replicaGroupId?: string,
      );

      /**
       * The id of the adapter.
       */
      id: string;

      /**
       * A dummy direct proxy that contains the adapter endpoints.
       */
      proxy: Ice.ObjectPrx | null;

      /**
       * The replica group id of the object adapter, or empty if the
       * adapter doesn't belong to a replica group.
       */
      replicaGroupId: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of adapter information structures.
     */
    type AdapterInfoSeq = Array<AdapterInfo>;

    /**
     * Information about a server managed by an IceGrid node.
     */
    class ServerInfo implements Ice.Struct {
      constructor(
        application?: string,
        uuid?: string,
        revision?: number,
        node?: string,
        descriptor?: ServerDescriptor | null,
        sessionId?: string,
      );

      /**
       * The server application.
       */
      application: string;

      /**
       * The application uuid.
       */
      uuid: string;

      /**
       * The application revision.
       */
      revision: number;

      /**
       * The server node.
       */
      node: string;

      /**
       * The server descriptor.
       */
      descriptor: ServerDescriptor | null;

      /**
       * The id of the session which allocated the server.
       */
      sessionId: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * Information about an IceGrid node.
     */
    class NodeInfo implements Ice.Struct {
      constructor(
        name?: string,
        os?: string,
        hostname?: string,
        release?: string,
        version?: string,
        machine?: string,
        nProcessors?: number,
        dataDir?: string,
      );

      /**
       * The name of the node.
       */
      name: string;

      /**
       * The operating system name.
       */
      os: string;

      /**
       * The network name of the host running this node (as defined in
       * uname()).
       */
      hostname: string;

      /**
       * The operation system release level (as defined in uname()).
       */
      release: string;

      /**
       * The operation system version (as defined in uname()).
       */
      version: string;

      /**
       * The machine hardware type (as defined in uname()).
       */
      machine: string;

      /**
       * The number of processor threads on the node.
       * For example, nProcessors is 8 on a computer with a single quad-core
       * processor and two HT threads per core.
       */
      nProcessors: number;

      /**
       * The path to the node data directory.
       */
      dataDir: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * Information about an IceGrid registry replica.
     */
    class RegistryInfo implements Ice.Struct {
      constructor(name?: string, hostname?: string);

      /**
       * The name of the registry.
       */
      name: string;

      /**
       * The network name of the host running this registry (as defined in
       * uname()).
       */
      hostname: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of {@link RegistryInfo} structures.
     */
    type RegistryInfoSeq = Array<RegistryInfo>;

    /**
     * Information about the load of a node.
     */
    class LoadInfo implements Ice.Struct {
      constructor(avg1?: number, avg5?: number, avg15?: number);

      avg1: number;
      avg5: number;
      avg15: number;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * Information about an IceGrid application.
     */
    class ApplicationInfo implements Ice.Struct {
      constructor(
        uuid?: string,
        createTime?: Ice.Long,
        createUser?: string,
        updateTime?: Ice.Long,
        updateUser?: string,
        revision?: number,
        descriptor?: ApplicationDescriptor,
      );

      uuid: string;
      createTime: Ice.Long;
      createUser: string;
      updateTime: Ice.Long;
      updateUser: string;
      revision: number;
      descriptor: ApplicationDescriptor;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of {@link ApplicationInfo} structures.
     */
    type ApplicationInfoSeq = Array<ApplicationInfo>;

    /**
     * Information about updates to an IceGrid application.
     */
    class ApplicationUpdateInfo implements Ice.Struct {
      constructor(
        updateTime?: Ice.Long,
        updateUser?: string,
        revision?: number,
        descriptor?: ApplicationUpdateDescriptor,
      );

      updateTime: Ice.Long;
      updateUser: string;
      revision: number;
      descriptor: ApplicationUpdateDescriptor;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * The IceGrid administrative interface.
     * <p class="Warning">Allowing access to this interface
     * is a security risk! Please see the IceGrid documentation
     * for further information.
     */
    abstract class Admin extends Ice.Object {
      /**
       * Add an application to IceGrid.
       *
       * @param descriptor The application descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       */
      abstract addApplication(
        descriptor: ApplicationDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Synchronize a deployed application with the given application
       * descriptor. This operation will replace the current descriptor
       * with this new descriptor.
       *
       * @param descriptor The application descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract syncApplication(
        descriptor: ApplicationDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Update a deployed application with the given update application
       * descriptor.
       *
       * @param descriptor The update descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract updateApplication(
        descriptor: ApplicationUpdateDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Synchronize a deployed application with the given application
       * descriptor. This operation will replace the current descriptor
       * with this 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.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract syncApplicationWithoutRestart(
        descriptor: ApplicationDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Update a deployed application with the given update application
       * 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 update descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract updateApplicationWithoutRestart(
        descriptor: ApplicationUpdateDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Remove an application from IceGrid.
       *
       * @param name The application name.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract removeApplication(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Instantiate a server template from an application on the given
       * node.
       *
       * @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.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if server instantiation
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract instantiateServer(
        application: string,
        node: string,
        desc: ServerInstanceDescriptor,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Patch the given application data.
       *
       * @param name The application name.
       *
       * @param shutdown If true, the servers depending on the data to
       * patch will be shut down if necessary.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       *
       * @throws PatchException Raised if the patch failed.
       */
      abstract patchApplication(
        name: string,
        shutdown: boolean,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get an application descriptor.
       *
       * @param name The application name.
       *
       * @return The application descriptor.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      abstract getApplicationInfo(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<ApplicationInfo>;

      /**
       * Get the default application descriptor.
       *
       * @return The default application descriptor.
       *
       * @throws DeploymentException Raised if the default application
       * descriptor can't be accessed or is invalid.
       */
      abstract getDefaultApplicationDescriptor(
        current: Ice.Current,
      ): Ice.OperationResult<ApplicationDescriptor>;

      /**
       * Get all the IceGrid applications currently registered.
       *
       * @return The application names.
       */
      abstract getAllApplicationNames(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.StringSeq>;

      /**
       * Get the server information for the server with the given id.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @return The server information.
       */
      abstract getServerInfo(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<ServerInfo>;

      /**
       * Get a server's state.
       *
       * @param id The server id.
       *
       * @return The server state.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract getServerState(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<ServerState>;

      /**
       * Get a server's system process id. The process id is operating
       * system dependent.
       *
       * @param id The server id.
       *
       * @return The server's process id.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract getServerPid(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<number>;

      /**
       * Get 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.
       *
       * @return The category for server admin objects.
       */
      abstract getServerAdminCategory(
        current: Ice.Current,
      ): Ice.OperationResult<string>;

      /**
       * Get a proxy to the server's admin object.
       *
       * @param id The server id.
       *
       * @return A proxy to the server's admin object
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract getServerAdmin(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<Ice.ObjectPrx | null>;

      /**
       * Enable or disable 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.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract enableServer(
        id: string,
        enabled: boolean,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Check if the server is enabled or disabled.
       *
       * @param id The server id.
       *
       * @return True if the server is enabled.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract isServerEnabled(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<boolean>;

      /**
       * Start a server and wait for its activation.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws ServerStartException Raised if the server couldn't be
       * started.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract startServer(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Stop a server.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws ServerStopException Raised if the server couldn't be
       * stopped.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract stopServer(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Patch a server.
       *
       * @param id The server id.
       *
       * @param shutdown If true, servers depending on the data to patch
       * will be shut down if necessary.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       *
       * @throws PatchException Raised if the patch failed.
       */
      abstract patchServer(
        id: string,
        shutdown: boolean,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Send signal to a server.
       *
       * @param id The server id.
       *
       * @param signal The signal, for example SIGTERM or 15.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       *
       * @throws BadSignalException Raised if the signal is not recognized
       * by the target server.
       */
      abstract sendSignal(
        id: string,
        signal: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get all the server ids registered with IceGrid.
       *
       * @return The server ids.
       */
      abstract getAllServerIds(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.StringSeq>;

      /**
       * Get the adapter information for the replica group or adapter
       * with the given id.
       *
       * @param id The adapter id.
       *
       * @return A sequence of adapter information structures. If the
       * given id refers to an adapter, this sequence will contain only
       * one element. If the given id refers to a replica group, the
       * sequence will contain the adapter information of each member of
       * the replica group.
       *
       * @throws AdapterNotExistException Raised if the adapter or
       * replica group doesn't exist.
       */
      abstract getAdapterInfo(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<AdapterInfoSeq>;

      /**
       * Remove the adapter with the given id.
       *
       * @param id The adapter id.
       * @throws AdapterNotExistException Raised if the adapter doesn't
       * exist.
       *
       * @throws DeploymentException Raised if application deployment failed.
       */
      abstract removeAdapter(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get all the adapter ids registered with IceGrid.
       *
       * @return The adapter ids.
       */
      abstract getAllAdapterIds(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.StringSeq>;

      /**
       * Add an object to the object registry. IceGrid will get the
       * object type by calling <tt>ice_id</tt> on the given proxy. The object
       * must be reachable.
       *
       * @param obj The object to be added to the registry.
       *
       * @throws ObjectExistsException Raised if the object is already
       * registered.
       *
       * @throws DeploymentException Raised if the object can't be
       * added. This might be raised if the invocation on the proxy to
       * get the object type failed.
       */
      abstract addObject(
        obj: Ice.ObjectPrx | null,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Update 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 The object to be updated to the registry.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       *
       * @throws DeploymentException Raised if the object can't be
       * updated. This might happen if the object was added with a
       * deployment descriptor.
       */
      abstract updateObject(
        obj: Ice.ObjectPrx | null,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Add an object to the object registry and explicitly specify
       * its type.
       *
       * @param obj The object to be added to the registry.
       *
       * @param type The object type.
       *
       * @throws ObjectExistsException Raised if the object is already
       * registered.
       *
       * @throws DeploymentException Raised if application deployment failed.
       */
      abstract addObjectWithType(
        obj: Ice.ObjectPrx | null,
        type: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Remove 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 be removed from the
       * registry.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       *
       * @throws DeploymentException Raised if the object can't be
       * removed. This might happen if the object was added with a
       * deployment descriptor.
       */
      abstract removeObject(
        id: Ice.Identity,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get the object info for the object with the given identity.
       *
       * @param id The identity of the object.
       *
       * @return The object info.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       */
      abstract getObjectInfo(
        id: Ice.Identity,
        current: Ice.Current,
      ): Ice.OperationResult<ObjectInfo>;

      /**
       * Get the object info of all the registered objects with the
       * given type.
       *
       * @param type The type of the object.
       *
       * @return The object infos.
       */
      abstract getObjectInfosByType(
        type: string,
        current: Ice.Current,
      ): Ice.OperationResult<ObjectInfoSeq>;

      /**
       * Get 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 (<tt>*</tt>) character.
       *
       * @return All the object infos with a stringified identity
       * matching the given expression.
       */
      abstract getAllObjectInfos(
        expr: string,
        current: Ice.Current,
      ): Ice.OperationResult<ObjectInfoSeq>;

      /**
       * Ping an IceGrid node to see if it is active.
       *
       * @param name The node name.
       *
       * @return true if the node ping succeeded, false otherwise.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       */
      abstract pingNode(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<boolean>;

      /**
       * Get the load averages of the node.
       *
       * @param name The node name.
       *
       * @return The node load information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract getNodeLoad(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<LoadInfo>;

      /**
       * Get the node information for the node with the given name.
       *
       * @param name The node name.
       *
       * @return The node information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract getNodeInfo(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<NodeInfo>;

      /**
       * Get a proxy to the IceGrid node's admin object.
       *
       * @param name The IceGrid node name
       *
       * @return A proxy to the IceGrid node's admin object
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract getNodeAdmin(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<Ice.ObjectPrx | null>;

      /**
       * Get the number of physical processor sockets for the machine
       * running the node with the given name.
       *
       * Note that this method will return 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.
       *
       * @return The number of processor sockets or 1 if the number of
       * sockets can't determined.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract getNodeProcessorSocketCount(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<number>;

      /**
       * Shutdown an IceGrid node.
       *
       * @param name The node name.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract shutdownNode(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get the hostname of this node.
       *
       * @param name The node name.
       *
       * @return The node hostname.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      abstract getNodeHostname(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<string>;

      /**
       * Get all the IceGrid nodes currently registered.
       *
       * @return The node names.
       */
      abstract getAllNodeNames(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.StringSeq>;

      /**
       * Ping an IceGrid registry to see if it is active.
       *
       * @param name The registry name.
       *
       * @return true if the registry ping succeeded, false otherwise.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       */
      abstract pingRegistry(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<boolean>;

      /**
       * Get the registry information for the registry with the given name.
       *
       * @param name The registry name.
       *
       * @return The registry information.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry could not be
       * reached.
       */
      abstract getRegistryInfo(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<RegistryInfo>;

      /**
       * Get a proxy to the IceGrid registry's admin object.
       *
       * @param name The registry name
       *
       * @return A proxy to the IceGrid registry's admin object
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       */
      abstract getRegistryAdmin(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<Ice.ObjectPrx | null>;

      /**
       * Shutdown an IceGrid registry.
       *
       * @param name The registry name.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry could not be
       * reached.
       */
      abstract shutdownRegistry(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Get all the IceGrid registries currently registered.
       *
       * @return The registry names.
       */
      abstract getAllRegistryNames(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.StringSeq>;

      /**
       * Shut down the IceGrid registry.
       */
      abstract shutdown(current: Ice.Current): Ice.OperationResult<void>;

      /**
       * Returns the checksums for the IceGrid Slice definitions.
       *
       * @return A dictionary mapping Slice type ids to their checksums.
       */
      abstract getSliceChecksums(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.SliceChecksumDict>;
    }

    /**
     * The IceGrid administrative interface.
     * <p class="Warning">Allowing access to this interface
     * is a security risk! Please see the IceGrid documentation
     * for further information.
     */
    class AdminPrx extends Ice.ObjectPrx {
      /**
       * Add an application to IceGrid.
       *
       * @param descriptor The application descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       */
      addApplication(
        descriptor: ApplicationDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Synchronize a deployed application with the given application
       * descriptor. This operation will replace the current descriptor
       * with this new descriptor.
       *
       * @param descriptor The application descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      syncApplication(
        descriptor: ApplicationDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Update a deployed application with the given update application
       * descriptor.
       *
       * @param descriptor The update descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      updateApplication(
        descriptor: ApplicationUpdateDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Synchronize a deployed application with the given application
       * descriptor. This operation will replace the current descriptor
       * with this 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.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      syncApplicationWithoutRestart(
        descriptor: ApplicationDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Update a deployed application with the given update application
       * 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 update descriptor.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      updateApplicationWithoutRestart(
        descriptor: ApplicationUpdateDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Remove an application from IceGrid.
       *
       * @param name The application name.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if application deployment failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      removeApplication(name: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Instantiate a server template from an application on the given
       * node.
       *
       * @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.
       *
       * @throws AccessDeniedException Raised if the session doesn't
       * hold the exclusive lock or if another session is holding the
       * lock.
       *
       * @throws DeploymentException Raised if server instantiation
       * failed.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      instantiateServer(
        application: string,
        node: string,
        desc: ServerInstanceDescriptor,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Patch the given application data.
       *
       * @param name The application name.
       *
       * @param shutdown If true, the servers depending on the data to
       * patch will be shut down if necessary.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       *
       * @throws PatchException Raised if the patch failed.
       */
      patchApplication(
        name: string,
        shutdown: boolean,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Get an application descriptor.
       *
       * @param name The application name.
       *
       * @return The application descriptor.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      getApplicationInfo(
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ApplicationInfo>;

      /**
       * Get the default application descriptor.
       *
       * @return The default application descriptor.
       *
       * @throws DeploymentException Raised if the default application
       * descriptor can't be accessed or is invalid.
       */
      getDefaultApplicationDescriptor(
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ApplicationDescriptor>;

      /**
       * Get all the IceGrid applications currently registered.
       *
       * @return The application names.
       */
      getAllApplicationNames(ctx?: Ice.Context): Ice.AsyncResult<Ice.StringSeq>;

      /**
       * Get the server information for the server with the given id.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @return The server information.
       */
      getServerInfo(id: string, ctx?: Ice.Context): Ice.AsyncResult<ServerInfo>;

      /**
       * Get a server's state.
       *
       * @param id The server id.
       *
       * @return The server state.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      getServerState(
        id: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ServerState>;

      /**
       * Get a server's system process id. The process id is operating
       * system dependent.
       *
       * @param id The server id.
       *
       * @return The server's process id.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      getServerPid(id: string, ctx?: Ice.Context): Ice.AsyncResult<number>;

      /**
       * Get 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.
       *
       * @return The category for server admin objects.
       */
      getServerAdminCategory(ctx?: Ice.Context): Ice.AsyncResult<string>;

      /**
       * Get a proxy to the server's admin object.
       *
       * @param id The server id.
       *
       * @return A proxy to the server's admin object
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      getServerAdmin(
        id: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<Ice.ObjectPrx | null>;

      /**
       * Enable or disable 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.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      enableServer(
        id: string,
        enabled: boolean,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Check if the server is enabled or disabled.
       *
       * @param id The server id.
       *
       * @return True if the server is enabled.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      isServerEnabled(id: string, ctx?: Ice.Context): Ice.AsyncResult<boolean>;

      /**
       * Start a server and wait for its activation.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws ServerStartException Raised if the server couldn't be
       * started.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      startServer(id: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Stop a server.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws ServerStopException Raised if the server couldn't be
       * stopped.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      stopServer(id: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Patch a server.
       *
       * @param id The server id.
       *
       * @param shutdown If true, servers depending on the data to patch
       * will be shut down if necessary.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       *
       * @throws PatchException Raised if the patch failed.
       */
      patchServer(
        id: string,
        shutdown: boolean,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Send signal to a server.
       *
       * @param id The server id.
       *
       * @param signal The signal, for example SIGTERM or 15.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       *
       * @throws BadSignalException Raised if the signal is not recognized
       * by the target server.
       */
      sendSignal(
        id: string,
        signal: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Get all the server ids registered with IceGrid.
       *
       * @return The server ids.
       */
      getAllServerIds(ctx?: Ice.Context): Ice.AsyncResult<Ice.StringSeq>;

      /**
       * Get the adapter information for the replica group or adapter
       * with the given id.
       *
       * @param id The adapter id.
       *
       * @return A sequence of adapter information structures. If the
       * given id refers to an adapter, this sequence will contain only
       * one element. If the given id refers to a replica group, the
       * sequence will contain the adapter information of each member of
       * the replica group.
       *
       * @throws AdapterNotExistException Raised if the adapter or
       * replica group doesn't exist.
       */
      getAdapterInfo(
        id: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<AdapterInfoSeq>;

      /**
       * Remove the adapter with the given id.
       *
       * @param id The adapter id.
       * @throws AdapterNotExistException Raised if the adapter doesn't
       * exist.
       *
       * @throws DeploymentException Raised if application deployment failed.
       */
      removeAdapter(id: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get all the adapter ids registered with IceGrid.
       *
       * @return The adapter ids.
       */
      getAllAdapterIds(ctx?: Ice.Context): Ice.AsyncResult<Ice.StringSeq>;

      /**
       * Add an object to the object registry. IceGrid will get the
       * object type by calling <tt>ice_id</tt> on the given proxy. The object
       * must be reachable.
       *
       * @param obj The object to be added to the registry.
       *
       * @throws ObjectExistsException Raised if the object is already
       * registered.
       *
       * @throws DeploymentException Raised if the object can't be
       * added. This might be raised if the invocation on the proxy to
       * get the object type failed.
       */
      addObject(
        obj: Ice.ObjectPrx | null,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Update 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 The object to be updated to the registry.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       *
       * @throws DeploymentException Raised if the object can't be
       * updated. This might happen if the object was added with a
       * deployment descriptor.
       */
      updateObject(
        obj: Ice.ObjectPrx | null,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Add an object to the object registry and explicitly specify
       * its type.
       *
       * @param obj The object to be added to the registry.
       *
       * @param type The object type.
       *
       * @throws ObjectExistsException Raised if the object is already
       * registered.
       *
       * @throws DeploymentException Raised if application deployment failed.
       */
      addObjectWithType(
        obj: Ice.ObjectPrx | null,
        type: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Remove 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 be removed from the
       * registry.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       *
       * @throws DeploymentException Raised if the object can't be
       * removed. This might happen if the object was added with a
       * deployment descriptor.
       */
      removeObject(id: Ice.Identity, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get the object info for the object with the given identity.
       *
       * @param id The identity of the object.
       *
       * @return The object info.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       */
      getObjectInfo(
        id: Ice.Identity,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ObjectInfo>;

      /**
       * Get the object info of all the registered objects with the
       * given type.
       *
       * @param type The type of the object.
       *
       * @return The object infos.
       */
      getObjectInfosByType(
        type: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ObjectInfoSeq>;

      /**
       * Get 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 (<tt>*</tt>) character.
       *
       * @return All the object infos with a stringified identity
       * matching the given expression.
       */
      getAllObjectInfos(
        expr: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<ObjectInfoSeq>;

      /**
       * Ping an IceGrid node to see if it is active.
       *
       * @param name The node name.
       *
       * @return true if the node ping succeeded, false otherwise.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       */
      pingNode(name: string, ctx?: Ice.Context): Ice.AsyncResult<boolean>;

      /**
       * Get the load averages of the node.
       *
       * @param name The node name.
       *
       * @return The node load information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeLoad(name: string, ctx?: Ice.Context): Ice.AsyncResult<LoadInfo>;

      /**
       * Get the node information for the node with the given name.
       *
       * @param name The node name.
       *
       * @return The node information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeInfo(name: string, ctx?: Ice.Context): Ice.AsyncResult<NodeInfo>;

      /**
       * Get a proxy to the IceGrid node's admin object.
       *
       * @param name The IceGrid node name
       *
       * @return A proxy to the IceGrid node's admin object
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeAdmin(
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<Ice.ObjectPrx | null>;

      /**
       * Get the number of physical processor sockets for the machine
       * running the node with the given name.
       *
       * Note that this method will return 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.
       *
       * @return The number of processor sockets or 1 if the number of
       * sockets can't determined.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeProcessorSocketCount(
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<number>;

      /**
       * Shutdown an IceGrid node.
       *
       * @param name The node name.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      shutdownNode(name: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get the hostname of this node.
       *
       * @param name The node name.
       *
       * @return The node hostname.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeHostname(name: string, ctx?: Ice.Context): Ice.AsyncResult<string>;

      /**
       * Get all the IceGrid nodes currently registered.
       *
       * @return The node names.
       */
      getAllNodeNames(ctx?: Ice.Context): Ice.AsyncResult<Ice.StringSeq>;

      /**
       * Ping an IceGrid registry to see if it is active.
       *
       * @param name The registry name.
       *
       * @return true if the registry ping succeeded, false otherwise.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       */
      pingRegistry(name: string, ctx?: Ice.Context): Ice.AsyncResult<boolean>;

      /**
       * Get the registry information for the registry with the given name.
       *
       * @param name The registry name.
       *
       * @return The registry information.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry could not be
       * reached.
       */
      getRegistryInfo(
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<RegistryInfo>;

      /**
       * Get a proxy to the IceGrid registry's admin object.
       *
       * @param name The registry name
       *
       * @return A proxy to the IceGrid registry's admin object
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       */
      getRegistryAdmin(
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<Ice.ObjectPrx | null>;

      /**
       * Shutdown an IceGrid registry.
       *
       * @param name The registry name.
       *
       * @throws RegistryNotExistException Raised if the registry doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry could not be
       * reached.
       */
      shutdownRegistry(name: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get all the IceGrid registries currently registered.
       *
       * @return The registry names.
       */
      getAllRegistryNames(ctx?: Ice.Context): Ice.AsyncResult<Ice.StringSeq>;

      /**
       * Shut down the IceGrid registry.
       */
      shutdown(ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Returns the checksums for the IceGrid Slice definitions.
       *
       * @return A dictionary mapping Slice type ids to their checksums.
       */
      getSliceChecksums(
        ctx?: Ice.Context,
      ): Ice.AsyncResult<Ice.SliceChecksumDict>;
    }

    /**
     * This interface provides access to IceGrid log file contents.
     */
    abstract class FileIterator extends Ice.Object {
      /**
       * 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 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 '\n' should be added when writing
       * the last line to the to the output device).
       *
       * @return True if EOF is encountered.
       *
       * @throws FileNotAvailableException Raised if there was a problem
       * to read lines from the file.
       */
      abstract read(
        size: number,
        current: Ice.Current,
      ): Ice.OperationResult<[boolean, Ice.StringSeq]>;

      /**
       * Destroy the iterator.
       */
      abstract destroy(current: Ice.Current): Ice.OperationResult<void>;
    }

    /**
     * This interface provides access to IceGrid log file contents.
     */
    class FileIteratorPrx extends Ice.ObjectPrx {
      /**
       * 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 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 '\n' should be added when writing
       * the last line to the to the output device).
       *
       * @return True if EOF is encountered.
       *
       * @throws FileNotAvailableException Raised if there was a problem
       * to read lines from the file.
       */
      read(
        size: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<[boolean, Ice.StringSeq]>;

      /**
       * Destroy the iterator.
       */
      destroy(ctx?: Ice.Context): Ice.AsyncResult<void>;
    }

    /**
     * Dynamic information about the state of a server.
     */
    class ServerDynamicInfo implements Ice.Struct {
      constructor(
        id?: string,
        state?: ServerState,
        pid?: number,
        enabled?: boolean,
      );

      /**
       * The id of the server.
       */
      id: string;

      /**
       * The state of the server.
       */
      state: ServerState;

      /**
       * The process id of the server.
       */
      pid: number;

      /**
       * Indicates whether the server is enabled.
       */
      enabled: boolean;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of server dynamic information structures.
     */
    type ServerDynamicInfoSeq = Array<ServerDynamicInfo>;

    /**
     * Dynamic information about the state of an adapter.
     */
    class AdapterDynamicInfo implements Ice.Struct {
      constructor(id?: string, proxy?: Ice.ObjectPrx | null);

      /**
       * The id of the adapter.
       */
      id: string;

      /**
       * The direct proxy containing the adapter endpoints.
       */
      proxy: Ice.ObjectPrx | null;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of adapter dynamic information structures.
     */
    type AdapterDynamicInfoSeq = Array<AdapterDynamicInfo>;

    /**
     * Dynamic information about the state of a node.
     */
    class NodeDynamicInfo implements Ice.Struct {
      constructor(
        info?: NodeInfo,
        servers?: ServerDynamicInfoSeq,
        adapters?: AdapterDynamicInfoSeq,
      );

      /**
       * Some static information about the node.
       */
      info: NodeInfo;

      /**
       * The dynamic information of the servers deployed on this node.
       */
      servers: ServerDynamicInfoSeq;

      /**
       * The dynamic information of the adapters deployed on this node.
       */
      adapters: AdapterDynamicInfoSeq;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * This interface allows applications to monitor changes the state
     * of the registry.
     */
    abstract class RegistryObserver extends Ice.Object {
      /**
       * The <tt>registryInit</tt> operation is called after registration of
       * an observer to indicate the state of the registries.
       *
       * @param registries The current state of the registries.
       */
      abstract registryInit(
        registries: RegistryInfoSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>nodeUp</tt> operation is called to notify an observer that a node
       * came up.
       *
       * @param node The node state.
       */
      abstract registryUp(
        node: RegistryInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>nodeDown</tt> operation is called to notify an observer that a node
       * went down.
       *
       * @param name The node name.
       */
      abstract registryDown(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * This interface allows applications to monitor changes the state
     * of the registry.
     */
    class RegistryObserverPrx extends Ice.ObjectPrx {
      /**
       * The <tt>registryInit</tt> operation is called after registration of
       * an observer to indicate the state of the registries.
       *
       * @param registries The current state of the registries.
       */
      registryInit(
        registries: RegistryInfoSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>nodeUp</tt> operation is called to notify an observer that a node
       * came up.
       *
       * @param node The node state.
       */
      registryUp(node: RegistryInfo, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * The <tt>nodeDown</tt> operation is called to notify an observer that a node
       * went down.
       *
       * @param name The node name.
       */
      registryDown(name: string, ctx?: Ice.Context): Ice.AsyncResult<void>;
    }

    /**
     * A sequence of node dynamic information structures.
     */
    type NodeDynamicInfoSeq = Array<NodeDynamicInfo>;

    /**
     * The node observer interface. Observers should implement this
     * interface to receive information about the state of the IceGrid
     * nodes.
     */
    abstract class NodeObserver extends Ice.Object {
      /**
       * The <tt>nodeInit</tt> operation indicates the current state
       * of nodes. It is called after the registration of an observer.
       *
       * @param nodes The current state of the nodes.
       */
      abstract nodeInit(
        nodes: NodeDynamicInfoSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>nodeUp</tt> operation is called to notify an observer that a node
       * came up.
       *
       * @param node The node state.
       */
      abstract nodeUp(
        node: NodeDynamicInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>nodeDown</tt> operation is called to notify an observer that a node
       * went down.
       *
       * @param name The node name.
       */
      abstract nodeDown(
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>updateServer</tt> operation is called to notify an observer that
       * the state of a server changed.
       *
       * @param node The node hosting the server.
       *
       * @param updatedInfo The new server state.
       */
      abstract updateServer(
        node: string,
        updatedInfo: ServerDynamicInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>updateAdapter</tt> operation is called to notify an observer that
       * the state of an adapter changed.
       *
       * @param node The node hosting the adapter.
       *
       * @param updatedInfo The new adapter state.
       */
      abstract updateAdapter(
        node: string,
        updatedInfo: AdapterDynamicInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * The node observer interface. Observers should implement this
     * interface to receive information about the state of the IceGrid
     * nodes.
     */
    class NodeObserverPrx extends Ice.ObjectPrx {
      /**
       * The <tt>nodeInit</tt> operation indicates the current state
       * of nodes. It is called after the registration of an observer.
       *
       * @param nodes The current state of the nodes.
       */
      nodeInit(
        nodes: NodeDynamicInfoSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>nodeUp</tt> operation is called to notify an observer that a node
       * came up.
       *
       * @param node The node state.
       */
      nodeUp(node: NodeDynamicInfo, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * The <tt>nodeDown</tt> operation is called to notify an observer that a node
       * went down.
       *
       * @param name The node name.
       */
      nodeDown(name: string, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * The <tt>updateServer</tt> operation is called to notify an observer that
       * the state of a server changed.
       *
       * @param node The node hosting the server.
       *
       * @param updatedInfo The new server state.
       */
      updateServer(
        node: string,
        updatedInfo: ServerDynamicInfo,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>updateAdapter</tt> operation is called to notify an observer that
       * the state of an adapter changed.
       *
       * @param node The node hosting the adapter.
       *
       * @param updatedInfo The new adapter state.
       */
      updateAdapter(
        node: string,
        updatedInfo: AdapterDynamicInfo,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;
    }

    /**
     * The database observer interface. Observers should implement this
     * interface to receive information about the state of the IceGrid
     * registry database.
     */
    abstract class ApplicationObserver extends Ice.Object {
      /**
       * <tt>applicationInit</tt> is called after the registration
       * of an observer to indicate the state of the registry.
       *
       * @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.
       */
      abstract applicationInit(
        serial: number,
        applications: ApplicationInfoSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>applicationAdded</tt> operation is called to notify an observer
       * that an application was added.
       *
       * @param serial The new serial number of the registry database.
       *
       * @param desc The descriptor of the new application.
       */
      abstract applicationAdded(
        serial: number,
        desc: ApplicationInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>applicationRemoved</tt> operation is called to notify an 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.
       */
      abstract applicationRemoved(
        serial: number,
        name: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>applicationUpdated</tt> operation is called to notify an observer
       * that an application was updated.
       *
       * @param serial The new serial number of the registry database.
       *
       * @param desc The descriptor of the update.
       */
      abstract applicationUpdated(
        serial: number,
        desc: ApplicationUpdateInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * The database observer interface. Observers should implement this
     * interface to receive information about the state of the IceGrid
     * registry database.
     */
    class ApplicationObserverPrx extends Ice.ObjectPrx {
      /**
       * <tt>applicationInit</tt> is called after the registration
       * of an observer to indicate the state of the registry.
       *
       * @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.
       */
      applicationInit(
        serial: number,
        applications: ApplicationInfoSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>applicationAdded</tt> operation is called to notify an observer
       * that an application was added.
       *
       * @param serial The new serial number of the registry database.
       *
       * @param desc The descriptor of the new application.
       */
      applicationAdded(
        serial: number,
        desc: ApplicationInfo,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>applicationRemoved</tt> operation is called to notify an 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.
       */
      applicationRemoved(
        serial: number,
        name: string,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>applicationUpdated</tt> operation is called to notify an observer
       * that an application was updated.
       *
       * @param serial The new serial number of the registry database.
       *
       * @param desc The descriptor of the update.
       */
      applicationUpdated(
        serial: number,
        desc: ApplicationUpdateInfo,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;
    }

    /**
     * This interface allows applications to monitor the state of object
     * adapters that are registered with IceGrid.
     */
    abstract class AdapterObserver extends Ice.Object {
      /**
       * <tt>adapterInit</tt> is called after registration of
       * an observer to indicate the state of the registry.
       *
       * @param adpts The adapters that were dynamically registered
       * with the registry (not through the deployment mechanism).
       */
      abstract adapterInit(
        adpts: AdapterInfoSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>adapterAdded</tt> operation is called to notify an observer when
       * a dynamically-registered adapter was added.
       *
       * @param info The details of the new adapter.
       */
      abstract adapterAdded(
        info: AdapterInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The adapterUpdated operation is called to notify an observer when
       * a dynamically-registered adapter was updated.
       *
       * @param info The details of the updated adapter.
       */
      abstract adapterUpdated(
        info: AdapterInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The adapterRemoved operation is called to notify an observer when
       * a dynamically-registered adapter was removed.
       *
       * @param id The ID of the removed adapter.
       */
      abstract adapterRemoved(
        id: string,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * This interface allows applications to monitor the state of object
     * adapters that are registered with IceGrid.
     */
    class AdapterObserverPrx extends Ice.ObjectPrx {
      /**
       * <tt>adapterInit</tt> is called after registration of
       * an observer to indicate the state of the registry.
       *
       * @param adpts The adapters that were dynamically registered
       * with the registry (not through the deployment mechanism).
       */
      adapterInit(
        adpts: AdapterInfoSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>adapterAdded</tt> operation is called to notify an observer when
       * a dynamically-registered adapter was added.
       *
       * @param info The details of the new adapter.
       */
      adapterAdded(info: AdapterInfo, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * The adapterUpdated operation is called to notify an observer when
       * a dynamically-registered adapter was updated.
       *
       * @param info The details of the updated adapter.
       */
      adapterUpdated(
        info: AdapterInfo,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The adapterRemoved operation is called to notify an observer when
       * a dynamically-registered adapter was removed.
       *
       * @param id The ID of the removed adapter.
       */
      adapterRemoved(id: string, ctx?: Ice.Context): Ice.AsyncResult<void>;
    }

    /**
     * This interface allows applications to monitor IceGrid well-known objects.
     */
    abstract class ObjectObserver extends Ice.Object {
      /**
       * <tt>objectInit</tt> is called after the registration of
       * an observer to indicate the state of the registry.
       *
       * @param objects The objects registered with the {@link Admin}
       * interface (not through the deployment mechanism).
       */
      abstract objectInit(
        objects: ObjectInfoSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * The <tt>objectAdded</tt> operation is called to notify an observer when an
       * object was added to the {@link Admin} interface.
       *
       * @param info The details of the added object.
       */
      abstract objectAdded(
        info: ObjectInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * <tt>objectUpdated</tt> is called to notify an observer when
       * an object registered with the {@link Admin} interface was updated.
       *
       * @param info The details of the updated object.
       */
      abstract objectUpdated(
        info: ObjectInfo,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * <tt>objectRemoved</tt> is called to notify an observer when
       * an object registered with the {@link Admin} interface was removed.
       *
       * @param id The identity of the removed object.
       */
      abstract objectRemoved(
        id: Ice.Identity,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * This interface allows applications to monitor IceGrid well-known objects.
     */
    class ObjectObserverPrx extends Ice.ObjectPrx {
      /**
       * <tt>objectInit</tt> is called after the registration of
       * an observer to indicate the state of the registry.
       *
       * @param objects The objects registered with the {@link Admin}
       * interface (not through the deployment mechanism).
       */
      objectInit(
        objects: ObjectInfoSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * The <tt>objectAdded</tt> operation is called to notify an observer when an
       * object was added to the {@link Admin} interface.
       *
       * @param info The details of the added object.
       */
      objectAdded(info: ObjectInfo, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * <tt>objectUpdated</tt> is called to notify an observer when
       * an object registered with the {@link Admin} interface was updated.
       *
       * @param info The details of the updated object.
       */
      objectUpdated(info: ObjectInfo, ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * <tt>objectRemoved</tt> is called to notify an observer when
       * an object registered with the {@link Admin} interface was removed.
       *
       * @param id The identity of the removed object.
       */
      objectRemoved(id: Ice.Identity, ctx?: Ice.Context): Ice.AsyncResult<void>;
    }

    /**
     * Used by administrative clients to view,
     * update, and receive observer updates from the IceGrid
     * registry. Admin sessions are created either via the {@link Registry}
     * object or via the registry admin <tt>SessionManager</tt> object.
     *
     * @see Registry
     */
    abstract class AdminSession extends Ice.Object implements Glacier2.Session {
      /**
       * Destroy the session. This is called automatically when the router is destroyed.
       */
      abstract destroy(current: Ice.Current): Ice.OperationResult<void>;

      /**
       * Keep the session alive. Clients should call this operation
       * regularly to prevent the server from reaping the session.
       *
       * @see Registry#getSessionTimeout
       */
      abstract keepAlive(current: Ice.Current): Ice.OperationResult<void>;

      /**
       * Get the admin interface. The admin object returned by this
       * operation can only be accessed by the session.
       *
       * @return The admin interface proxy.
       */
      abstract getAdmin(
        current: Ice.Current,
      ): Ice.OperationResult<AdminPrx | null>;

      /**
       * Get 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.
       *
       * @return A template proxy. The returned proxy is null when the Admin
       * session was established using Glacier2.
       */
      abstract getAdminCallbackTemplate(
        current: Ice.Current,
      ): Ice.OperationResult<Ice.ObjectPrx | null>;

      /**
       * Set 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.
       *
       * @throws ObserverAlreadyRegisteredException Raised if an
       * observer is already registered with this registry.
       */
      abstract setObservers(
        registryObs: RegistryObserverPrx | null,
        nodeObs: NodeObserverPrx | null,
        appObs: ApplicationObserverPrx | null,
        adptObs: AdapterObserverPrx | null,
        objObs: ObjectObserverPrx | null,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Set the observer identities that receive
       * notifications 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.
       *
       * @throws ObserverAlreadyRegisteredException Raised if an
       * observer is already registered with this registry.
       */
      abstract setObserversByIdentity(
        registryObs: Ice.Identity,
        nodeObs: Ice.Identity,
        appObs: Ice.Identity,
        adptObs: Ice.Identity,
        objObs: Ice.Identity,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Acquires an exclusive lock to start updating the registry applications.
       *
       * @return The current serial.
       *
       * @throws AccessDeniedException Raised if the exclusive lock can't be
       * acquired. This might happen if the lock is currently acquired by
       * another session.
       */
      abstract startUpdate(current: Ice.Current): Ice.OperationResult<number>;

      /**
       * Finish updating the registry and release the exclusive lock.
       *
       * @throws AccessDeniedException Raised if the session doesn't hold the
       * exclusive lock.
       */
      abstract finishUpdate(current: Ice.Current): Ice.OperationResult<void>;

      /**
       * Get the name of the registry replica hosting this session.
       *
       * @return The replica name of the registry.
       */
      abstract getReplicaName(
        current: Ice.Current,
      ): Ice.OperationResult<string>;

      /**
       * Open the given server log file for reading. The file can be
       * read with the returned file iterator.
       *
       * @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 begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract openServerLog(
        id: string,
        path: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given server stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param id The server id.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract openServerStdErr(
        id: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given server stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param id The server id.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      abstract openServerStdOut(
        id: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given node stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The node name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       */
      abstract openNodeStdErr(
        name: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given node stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The node name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       */
      abstract openNodeStdOut(
        name: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given registry stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The registry name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws RegistryNotExistException Raised if the registry
       * doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry
       * could not be reached.
       */
      abstract openRegistryStdErr(
        name: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;

      /**
       * Open the given registry stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The registry name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws RegistryNotExistException Raised if the registry
       * doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry
       * could not be reached.
       */
      abstract openRegistryStdOut(
        name: string,
        count: number,
        current: Ice.Current,
      ): Ice.OperationResult<FileIteratorPrx | null>;
    }

    /**
     * Used by administrative clients to view,
     * update, and receive observer updates from the IceGrid
     * registry. Admin sessions are created either via the {@link Registry}
     * object or via the registry admin <tt>SessionManager</tt> object.
     *
     * @see Registry
     */
    class AdminSessionPrx extends Ice.ObjectPrx implements Glacier2.SessionPrx {
      /**
       * Destroy the session. This is called automatically when the router is destroyed.
       */
      destroy(ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Keep the session alive. Clients should call this operation
       * regularly to prevent the server from reaping the session.
       *
       * @see Registry#getSessionTimeout
       */
      keepAlive(ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get the admin interface. The admin object returned by this
       * operation can only be accessed by the session.
       *
       * @return The admin interface proxy.
       */
      getAdmin(ctx?: Ice.Context): Ice.AsyncResult<AdminPrx | null>;

      /**
       * Get 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.
       *
       * @return A template proxy. The returned proxy is null when the Admin
       * session was established using Glacier2.
       */
      getAdminCallbackTemplate(
        ctx?: Ice.Context,
      ): Ice.AsyncResult<Ice.ObjectPrx | null>;

      /**
       * Set 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.
       *
       * @throws ObserverAlreadyRegisteredException Raised if an
       * observer is already registered with this registry.
       */
      setObservers(
        registryObs: RegistryObserverPrx | null,
        nodeObs: NodeObserverPrx | null,
        appObs: ApplicationObserverPrx | null,
        adptObs: AdapterObserverPrx | null,
        objObs: ObjectObserverPrx | null,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Set the observer identities that receive
       * notifications 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.
       *
       * @throws ObserverAlreadyRegisteredException Raised if an
       * observer is already registered with this registry.
       */
      setObserversByIdentity(
        registryObs: Ice.Identity,
        nodeObs: Ice.Identity,
        appObs: Ice.Identity,
        adptObs: Ice.Identity,
        objObs: Ice.Identity,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Acquires an exclusive lock to start updating the registry applications.
       *
       * @return The current serial.
       *
       * @throws AccessDeniedException Raised if the exclusive lock can't be
       * acquired. This might happen if the lock is currently acquired by
       * another session.
       */
      startUpdate(ctx?: Ice.Context): Ice.AsyncResult<number>;

      /**
       * Finish updating the registry and release the exclusive lock.
       *
       * @throws AccessDeniedException Raised if the session doesn't hold the
       * exclusive lock.
       */
      finishUpdate(ctx?: Ice.Context): Ice.AsyncResult<void>;

      /**
       * Get the name of the registry replica hosting this session.
       *
       * @return The replica name of the registry.
       */
      getReplicaName(ctx?: Ice.Context): Ice.AsyncResult<string>;

      /**
       * Open the given server log file for reading. The file can be
       * read with the returned file iterator.
       *
       * @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 begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      openServerLog(
        id: string,
        path: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given server stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param id The server id.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      openServerStdErr(
        id: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given server stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param id The server id.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws ServerNotExistException Raised if the server doesn't
       * exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       *
       * @throws DeploymentException Raised if the server couldn't be
       * deployed on the node.
       */
      openServerStdOut(
        id: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given node stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The node name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       */
      openNodeStdErr(
        name: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given node stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The node name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not
       * be reached.
       */
      openNodeStdOut(
        name: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given registry stderr file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The registry name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws RegistryNotExistException Raised if the registry
       * doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry
       * could not be reached.
       */
      openRegistryStdErr(
        name: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;

      /**
       * Open the given registry stdout file for reading. The file can be
       * read with the returned file iterator.
       *
       * @param name The registry name.
       *
       * @param count Specifies where to start reading the file. If
       * negative, the file is read from the begining. If 0 or positive,
       * the file is read from the last <tt>count</tt> lines.
       *
       * @return An iterator to read the file.
       *
       * @throws FileNotAvailableException Raised if the file can't be
       * read.
       *
       * @throws RegistryNotExistException Raised if the registry
       * doesn't exist.
       *
       * @throws RegistryUnreachableException Raised if the registry
       * could not be reached.
       */
      openRegistryStdOut(
        name: string,
        count: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<FileIteratorPrx | null>;
    }
  }
}
export {IceGrid} from './IceGrid.ns';