//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.11
//
// <auto-generated>
//
// Generated from file `Descriptor.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//


export namespace IceGrid
{
    /**
     * A mapping of string to string.
     */
    class StringStringDict extends Map<string, string>
    {
    }

    class StringStringDictHelper
    {
        static write(outs:Ice.OutputStream, value:StringStringDict):void;
        static read(ins:Ice.InputStream):StringStringDict;
    }

    /**
     * Property descriptor.
     */
    class PropertyDescriptor
    {
        constructor(name?:string, value?:string);
        clone():PropertyDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        name:string;
        value:string;
        static write(outs:Ice.OutputStream, value:PropertyDescriptor):void;
        static read(ins:Ice.InputStream):PropertyDescriptor;
    }

    /**
     * A sequence of property descriptors.
     */
    type PropertyDescriptorSeq = PropertyDescriptor[];

    class PropertyDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:PropertyDescriptorSeq):void;
        static read(ins:Ice.InputStream):PropertyDescriptorSeq;
    }

    /**
     * A property set descriptor.
     */
    class PropertySetDescriptor
    {
        constructor(references?:Ice.StringSeq, properties?:PropertyDescriptorSeq);
        clone():PropertySetDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        references:Ice.StringSeq;
        properties:PropertyDescriptorSeq;
        static write(outs:Ice.OutputStream, value:PropertySetDescriptor):void;
        static read(ins:Ice.InputStream):PropertySetDescriptor;
    }

    /**
     * A mapping of property set name to property set descriptor.
     */
    class PropertySetDescriptorDict extends Map<string, PropertySetDescriptor>
    {
    }

    class PropertySetDescriptorDictHelper
    {
        static write(outs:Ice.OutputStream, value:PropertySetDescriptorDict):void;
        static read(ins:Ice.InputStream):PropertySetDescriptorDict;
    }

    /**
     * An Ice object descriptor.
     */
    class ObjectDescriptor
    {
        constructor(id?:Ice.Identity, type?:string, proxyOptions?:string);
        clone():ObjectDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        id:Ice.Identity;
        type:string;
        proxyOptions:string;
        static write(outs:Ice.OutputStream, value:ObjectDescriptor):void;
        static read(ins:Ice.InputStream):ObjectDescriptor;
    }

    /**
     * A sequence of object descriptors.
     */
    type ObjectDescriptorSeq = ObjectDescriptor[];

    class ObjectDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ObjectDescriptorSeq):void;
        static read(ins:Ice.InputStream):ObjectDescriptorSeq;
    }

    /**
     * An Ice object adapter descriptor.
     */
    class AdapterDescriptor
    {
        constructor(name?:string, description?:string, id?:string, replicaGroupId?:string, priority?:string, registerProcess?:boolean, serverLifetime?:boolean, objects?:ObjectDescriptorSeq, allocatables?:ObjectDescriptorSeq);
        clone():AdapterDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        name:string;
        description:string;
        id:string;
        replicaGroupId:string;
        priority:string;
        registerProcess:boolean;
        serverLifetime:boolean;
        objects:ObjectDescriptorSeq;
        allocatables:ObjectDescriptorSeq;
        static write(outs:Ice.OutputStream, value:AdapterDescriptor):void;
        static read(ins:Ice.InputStream):AdapterDescriptor;
    }

    /**
     * A sequence of adapter descriptors.
     */
    type AdapterDescriptorSeq = AdapterDescriptor[];

    class AdapterDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:AdapterDescriptorSeq):void;
        static read(ins:Ice.InputStream):AdapterDescriptorSeq;
    }

    /**
     * A Freeze database environment descriptor.
     */
    class DbEnvDescriptor
    {
        constructor(name?:string, description?:string, dbHome?:string, properties?:PropertyDescriptorSeq);
        clone():DbEnvDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        name:string;
        description:string;
        dbHome:string;
        properties:PropertyDescriptorSeq;
        static write(outs:Ice.OutputStream, value:DbEnvDescriptor):void;
        static read(ins:Ice.InputStream):DbEnvDescriptor;
    }

    /**
     * A sequence of database environment descriptors.
     */
    type DbEnvDescriptorSeq = DbEnvDescriptor[];

    class DbEnvDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:DbEnvDescriptorSeq):void;
        static read(ins:Ice.InputStream):DbEnvDescriptorSeq;
    }

    /**
     * A communicator descriptor.
     */
    class CommunicatorDescriptor extends Ice.Value
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param adapters The object adapters.
         * @param propertySet The property set.
         * @param dbEnvs The database environments.
         * @param logs The path of each log file.
         * @param description A description of this descriptor.
         */
        constructor(adapters?:AdapterDescriptorSeq, propertySet?:PropertySetDescriptor, dbEnvs?:DbEnvDescriptorSeq, logs?:Ice.StringSeq, description?:string);
        /**
         * The object adapters.
         */
        adapters:AdapterDescriptorSeq;
        /**
         * The property set.
         */
        propertySet:PropertySetDescriptor;
        /**
         * The database environments.
         */
        dbEnvs:DbEnvDescriptorSeq;
        /**
         * The path of each log file.
         */
        logs:Ice.StringSeq;
        /**
         * A description of this descriptor.
         */
        description:string;
    }

    /**
     * A distribution descriptor defines an IcePatch2 server and the
     * directories to retrieve from the patch server.
     */
    class DistributionDescriptor
    {
        constructor(icepatch?:string, directories?:Ice.StringSeq);
        clone():DistributionDescriptor;
        equals(rhs:any):boolean;
        hashCode():number;
        icepatch:string;
        directories:Ice.StringSeq;
        static write(outs:Ice.OutputStream, value:DistributionDescriptor):void;
        static read(ins:Ice.InputStream):DistributionDescriptor;
    }

    /**
     * An Ice server descriptor.
     */
    class ServerDescriptor extends CommunicatorDescriptor
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param adapters The object adapters.
         * @param propertySet The property set.
         * @param dbEnvs The database environments.
         * @param logs The path of each log file.
         * @param description A description of this descriptor.
         * @param id The server id.
         * @param exe The path of the server executable.
         * @param iceVersion The Ice version used by this server.
         * @param pwd The path to the server working directory.
         * @param options The command line options to pass to the server executable.
         * @param envs The server environment variables.
         * @param activation The server activation mode (possible values are "on-demand" or "manual").
         * @param activationTimeout The activation timeout (an integer value representing the number of seconds to wait for activation).
         * @param deactivationTimeout The deactivation timeout (an integer value representing the number of seconds to wait for deactivation).
         * @param applicationDistrib Specifies if the server depends on the application distribution.
         * @param distrib The distribution descriptor.
         * @param allocatable Specifies if the server is allocatable.
         * @param user The user account used to run the server.
         */
        constructor(adapters?:AdapterDescriptorSeq, propertySet?:PropertySetDescriptor, dbEnvs?:DbEnvDescriptorSeq, logs?:Ice.StringSeq, description?:string, id?:string, exe?:string, iceVersion?:string, pwd?:string, options?:Ice.StringSeq, envs?:Ice.StringSeq, activation?:string, activationTimeout?:string, deactivationTimeout?:string, applicationDistrib?:boolean, distrib?:DistributionDescriptor, allocatable?:boolean, user?:string);
        /**
         * The server id.
         */
        id:string;
        /**
         * The path of the server executable.
         */
        exe:string;
        /**
         * The Ice version used by this server. This is only required if
         * backward compatibility with servers using old Ice versions is
         * needed (otherwise the registry will assume the server is using
         * the same Ice version).
         * For example "3.1.1", "3.2", "3.3.0".
         */
        iceVersion:string;
        /**
         * The path to the server working directory.
         */
        pwd:string;
        /**
         * The command line options to pass to the server executable.
         */
        options:Ice.StringSeq;
        /**
         * The server environment variables.
         */
        envs:Ice.StringSeq;
        /**
         * The server activation mode (possible values are "on-demand" or
         * "manual").
         */
        activation:string;
        /**
         * The activation timeout (an integer value representing the
         * number of seconds to wait for activation).
         */
        activationTimeout:string;
        /**
         * The deactivation timeout (an integer value representing the
         * number of seconds to wait for deactivation).
         */
        deactivationTimeout:string;
        /**
         * Specifies if the server depends on the application
         * distribution.
         */
        applicationDistrib:boolean;
        /**
         * The distribution descriptor.
         */
        distrib:DistributionDescriptor;
        /**
         * Specifies if the server is allocatable.
         */
        allocatable:boolean;
        /**
         * The user account used to run the server.
         */
        user:string;
    }

    /**
     * A sequence of server descriptors.
     */
    type ServerDescriptorSeq = IceGrid.ServerDescriptor[];

    class ServerDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ServerDescriptorSeq):void;
        static read(ins:Ice.InputStream):ServerDescriptorSeq;
    }

    /**
     * An IceBox service descriptor.
     */
    class ServiceDescriptor extends CommunicatorDescriptor
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param adapters The object adapters.
         * @param propertySet The property set.
         * @param dbEnvs The database environments.
         * @param logs The path of each log file.
         * @param description A description of this descriptor.
         * @param name The service name.
         * @param entry The entry point of the IceBox service.
         */
        constructor(adapters?:AdapterDescriptorSeq, propertySet?:PropertySetDescriptor, dbEnvs?:DbEnvDescriptorSeq, logs?:Ice.StringSeq, description?:string, name?:string, entry?:string);
        /**
         * The service name.
         */
        name:string;
        /**
         * The entry point of the IceBox service.
         */
        entry:string;
    }

    /**
     * A sequence of service descriptors.
     */
    type ServiceDescriptorSeq = IceGrid.ServiceDescriptor[];

    class ServiceDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ServiceDescriptorSeq):void;
        static read(ins:Ice.InputStream):ServiceDescriptorSeq;
    }

    /**
     * A server template instance descriptor.
     */
    class ServerInstanceDescriptor
    {
        constructor(template?:string, parameterValues?:StringStringDict, propertySet?:PropertySetDescriptor, servicePropertySets?:PropertySetDescriptorDict);
        clone():ServerInstanceDescriptor;
        equals(rhs:any):boolean;
        template:string;
        parameterValues:StringStringDict;
        propertySet:PropertySetDescriptor;
        servicePropertySets:PropertySetDescriptorDict;
        static write(outs:Ice.OutputStream, value:ServerInstanceDescriptor):void;
        static read(ins:Ice.InputStream):ServerInstanceDescriptor;
    }

    /**
     * A sequence of server instance descriptors.
     */
    type ServerInstanceDescriptorSeq = ServerInstanceDescriptor[];

    class ServerInstanceDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ServerInstanceDescriptorSeq):void;
        static read(ins:Ice.InputStream):ServerInstanceDescriptorSeq;
    }

    /**
     * A template descriptor for server or service templates.
     */
    class TemplateDescriptor
    {
        constructor(descriptor?:IceGrid.CommunicatorDescriptor, parameters?:Ice.StringSeq, parameterDefaults?:StringStringDict);
        clone():TemplateDescriptor;
        equals(rhs:any):boolean;
        descriptor:IceGrid.CommunicatorDescriptor;
        parameters:Ice.StringSeq;
        parameterDefaults:StringStringDict;
        static write(outs:Ice.OutputStream, value:TemplateDescriptor):void;
        static read(ins:Ice.InputStream):TemplateDescriptor;
    }

    /**
     * A mapping of template identifier to template descriptor.
     */
    class TemplateDescriptorDict extends Map<string, TemplateDescriptor>
    {
    }

    class TemplateDescriptorDictHelper
    {
        static write(outs:Ice.OutputStream, value:TemplateDescriptorDict):void;
        static read(ins:Ice.InputStream):TemplateDescriptorDict;
    }

    /**
     * A service template instance descriptor.
     */
    class ServiceInstanceDescriptor
    {
        constructor(template?:string, parameterValues?:StringStringDict, descriptor?:IceGrid.ServiceDescriptor, propertySet?:PropertySetDescriptor);
        clone():ServiceInstanceDescriptor;
        equals(rhs:any):boolean;
        template:string;
        parameterValues:StringStringDict;
        descriptor:IceGrid.ServiceDescriptor;
        propertySet:PropertySetDescriptor;
        static write(outs:Ice.OutputStream, value:ServiceInstanceDescriptor):void;
        static read(ins:Ice.InputStream):ServiceInstanceDescriptor;
    }

    /**
     * A sequence of service instance descriptors.
     */
    type ServiceInstanceDescriptorSeq = ServiceInstanceDescriptor[];

    class ServiceInstanceDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ServiceInstanceDescriptorSeq):void;
        static read(ins:Ice.InputStream):ServiceInstanceDescriptorSeq;
    }

    /**
     * An IceBox server descriptor.
     */
    class IceBoxDescriptor extends ServerDescriptor
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param adapters The object adapters.
         * @param propertySet The property set.
         * @param dbEnvs The database environments.
         * @param logs The path of each log file.
         * @param description A description of this descriptor.
         * @param id The server id.
         * @param exe The path of the server executable.
         * @param iceVersion The Ice version used by this server.
         * @param pwd The path to the server working directory.
         * @param options The command line options to pass to the server executable.
         * @param envs The server environment variables.
         * @param activation The server activation mode (possible values are "on-demand" or "manual").
         * @param activationTimeout The activation timeout (an integer value representing the number of seconds to wait for activation).
         * @param deactivationTimeout The deactivation timeout (an integer value representing the number of seconds to wait for deactivation).
         * @param applicationDistrib Specifies if the server depends on the application distribution.
         * @param distrib The distribution descriptor.
         * @param allocatable Specifies if the server is allocatable.
         * @param user The user account used to run the server.
         * @param services The service instances.
         */
        constructor(adapters?:AdapterDescriptorSeq, propertySet?:PropertySetDescriptor, dbEnvs?:DbEnvDescriptorSeq, logs?:Ice.StringSeq, description?:string, id?:string, exe?:string, iceVersion?:string, pwd?:string, options?:Ice.StringSeq, envs?:Ice.StringSeq, activation?:string, activationTimeout?:string, deactivationTimeout?:string, applicationDistrib?:boolean, distrib?:DistributionDescriptor, allocatable?:boolean, user?:string, services?:ServiceInstanceDescriptorSeq);
        /**
         * The service instances.
         */
        services:ServiceInstanceDescriptorSeq;
    }

    /**
     * A node descriptor.
     */
    class NodeDescriptor
    {
        constructor(variables?:StringStringDict, serverInstances?:ServerInstanceDescriptorSeq, servers?:ServerDescriptorSeq, loadFactor?:string, description?:string, propertySets?:PropertySetDescriptorDict);
        clone():NodeDescriptor;
        equals(rhs:any):boolean;
        variables:StringStringDict;
        serverInstances:ServerInstanceDescriptorSeq;
        servers:ServerDescriptorSeq;
        loadFactor:string;
        description:string;
        propertySets:PropertySetDescriptorDict;
        static write(outs:Ice.OutputStream, value:NodeDescriptor):void;
        static read(ins:Ice.InputStream):NodeDescriptor;
    }

    /**
     * Mapping of node name to node descriptor.
     */
    class NodeDescriptorDict extends Map<string, NodeDescriptor>
    {
    }

    class NodeDescriptorDictHelper
    {
        static write(outs:Ice.OutputStream, value:NodeDescriptorDict):void;
        static read(ins:Ice.InputStream):NodeDescriptorDict;
    }

    /**
     * A base class for load balancing policies.
     */
    class LoadBalancingPolicy extends Ice.Value
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
         */
        constructor(nReplicas?:string);
        /**
         * The number of replicas that will be used to gather the
         * endpoints of a replica group.
         */
        nReplicas:string;
    }

    /**
     * Random load balancing policy.
     */
    class RandomLoadBalancingPolicy extends LoadBalancingPolicy
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
         */
        constructor(nReplicas?:string);
    }

    /**
     * Ordered load balancing policy.
     */
    class OrderedLoadBalancingPolicy extends LoadBalancingPolicy
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
         */
        constructor(nReplicas?:string);
    }

    /**
     * Round robin load balancing policy.
     */
    class RoundRobinLoadBalancingPolicy extends LoadBalancingPolicy
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
         */
        constructor(nReplicas?:string);
    }

    /**
     * Adaptive load balancing policy.
     */
    class AdaptiveLoadBalancingPolicy extends LoadBalancingPolicy
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param nReplicas The number of replicas that will be used to gather the endpoints of a replica group.
         * @param loadSample The load sample to use for the load balancing.
         */
        constructor(nReplicas?:string, loadSample?:string);
        /**
         * The load sample to use for the load balancing. The allowed
         * values for this attribute are "1", "5" and "15", representing
         * respectively the load average over the past minute, the past 5
         * minutes and the past 15 minutes.
         */
        loadSample:string;
    }

    /**
     * A replica group descriptor.
     */
    class ReplicaGroupDescriptor
    {
        constructor(id?:string, loadBalancing?:IceGrid.LoadBalancingPolicy, proxyOptions?:string, objects?:ObjectDescriptorSeq, description?:string, filter?:string);
        clone():ReplicaGroupDescriptor;
        equals(rhs:any):boolean;
        id:string;
        loadBalancing:IceGrid.LoadBalancingPolicy;
        proxyOptions:string;
        objects:ObjectDescriptorSeq;
        description:string;
        filter:string;
        static write(outs:Ice.OutputStream, value:ReplicaGroupDescriptor):void;
        static read(ins:Ice.InputStream):ReplicaGroupDescriptor;
    }

    /**
     * A sequence of replica groups.
     */
    type ReplicaGroupDescriptorSeq = ReplicaGroupDescriptor[];

    class ReplicaGroupDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ReplicaGroupDescriptorSeq):void;
        static read(ins:Ice.InputStream):ReplicaGroupDescriptorSeq;
    }

    /**
     * An application descriptor.
     */
    class ApplicationDescriptor
    {
        constructor(name?:string, variables?:StringStringDict, replicaGroups?:ReplicaGroupDescriptorSeq, serverTemplates?:TemplateDescriptorDict, serviceTemplates?:TemplateDescriptorDict, nodes?:NodeDescriptorDict, distrib?:DistributionDescriptor, description?:string, propertySets?:PropertySetDescriptorDict);
        clone():ApplicationDescriptor;
        equals(rhs:any):boolean;
        name:string;
        variables:StringStringDict;
        replicaGroups:ReplicaGroupDescriptorSeq;
        serverTemplates:TemplateDescriptorDict;
        serviceTemplates:TemplateDescriptorDict;
        nodes:NodeDescriptorDict;
        distrib:DistributionDescriptor;
        description:string;
        propertySets:PropertySetDescriptorDict;
        static write(outs:Ice.OutputStream, value:ApplicationDescriptor):void;
        static read(ins:Ice.InputStream):ApplicationDescriptor;
    }

    /**
     * A sequence of application descriptors.
     */
    type ApplicationDescriptorSeq = ApplicationDescriptor[];

    class ApplicationDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:ApplicationDescriptorSeq):void;
        static read(ins:Ice.InputStream):ApplicationDescriptorSeq;
    }

    /**
     * A "boxed" string.
     */
    class BoxedString extends Ice.Value
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param value The value of the boxed string.
         */
        constructor(value?:string);
        /**
         * The value of the boxed string.
         */
        value:string;
    }

    /**
     * A node update descriptor to describe the updates to apply to a
     * node of a deployed application.
     */
    class NodeUpdateDescriptor
    {
        constructor(name?:string, description?:IceGrid.BoxedString, variables?:StringStringDict, removeVariables?:Ice.StringSeq, propertySets?:PropertySetDescriptorDict, removePropertySets?:Ice.StringSeq, serverInstances?:ServerInstanceDescriptorSeq, servers?:ServerDescriptorSeq, removeServers?:Ice.StringSeq, loadFactor?:IceGrid.BoxedString);
        clone():NodeUpdateDescriptor;
        equals(rhs:any):boolean;
        name:string;
        description:IceGrid.BoxedString;
        variables:StringStringDict;
        removeVariables:Ice.StringSeq;
        propertySets:PropertySetDescriptorDict;
        removePropertySets:Ice.StringSeq;
        serverInstances:ServerInstanceDescriptorSeq;
        servers:ServerDescriptorSeq;
        removeServers:Ice.StringSeq;
        loadFactor:IceGrid.BoxedString;
        static write(outs:Ice.OutputStream, value:NodeUpdateDescriptor):void;
        static read(ins:Ice.InputStream):NodeUpdateDescriptor;
    }

    /**
     * A sequence of node update descriptors.
     */
    type NodeUpdateDescriptorSeq = NodeUpdateDescriptor[];

    class NodeUpdateDescriptorSeqHelper
    {
        static write(outs:Ice.OutputStream, value:NodeUpdateDescriptorSeq):void;
        static read(ins:Ice.InputStream):NodeUpdateDescriptorSeq;
    }

    /**
     * A "boxed" distribution descriptor.
     */
    class BoxedDistributionDescriptor extends Ice.Value
    {
        /**
         * One-shot constructor to initialize all data members.
         * @param value The value of the boxed distribution descriptor.
         */
        constructor(value?:DistributionDescriptor);
        /**
         * The value of the boxed distribution descriptor.
         */
        value:DistributionDescriptor;
    }

    /**
     * An application update descriptor to describe the updates to apply
     * to a deployed application.
     */
    class ApplicationUpdateDescriptor
    {
        constructor(name?:string, description?:IceGrid.BoxedString, distrib?:IceGrid.BoxedDistributionDescriptor, variables?:StringStringDict, removeVariables?:Ice.StringSeq, propertySets?:PropertySetDescriptorDict, removePropertySets?:Ice.StringSeq, replicaGroups?:ReplicaGroupDescriptorSeq, removeReplicaGroups?:Ice.StringSeq, serverTemplates?:TemplateDescriptorDict, removeServerTemplates?:Ice.StringSeq, serviceTemplates?:TemplateDescriptorDict, removeServiceTemplates?:Ice.StringSeq, nodes?:NodeUpdateDescriptorSeq, removeNodes?:Ice.StringSeq);
        clone():ApplicationUpdateDescriptor;
        equals(rhs:any):boolean;
        name:string;
        description:IceGrid.BoxedString;
        distrib:IceGrid.BoxedDistributionDescriptor;
        variables:StringStringDict;
        removeVariables:Ice.StringSeq;
        propertySets:PropertySetDescriptorDict;
        removePropertySets:Ice.StringSeq;
        replicaGroups:ReplicaGroupDescriptorSeq;
        removeReplicaGroups:Ice.StringSeq;
        serverTemplates:TemplateDescriptorDict;
        removeServerTemplates:Ice.StringSeq;
        serviceTemplates:TemplateDescriptorDict;
        removeServiceTemplates:Ice.StringSeq;
        nodes:NodeUpdateDescriptorSeq;
        removeNodes:Ice.StringSeq;
        static write(outs:Ice.OutputStream, value:ApplicationUpdateDescriptor):void;
        static read(ins:Ice.InputStream):ApplicationUpdateDescriptor;
    }
}