windows-xp/Source/XPSP1/NT/ds/dns/server/wmi/doc/dnsprov.mof

#pragma namespace ("\\\\.\\Root")

instance of __NameSpace
{
    Name = "MicrosoftDNS" ;
} ;

#pragma namespace ( "\\\\.\\Root\\MicrosoftDNS" ) 


instance of __Win32Provider as $P
{
    Name = "MS_NT_DNS_PROVIDER";
    ClsId = "{62269fec-7b32-11d2-9ab7-0000f875c5d4}";
    ImpersonationLevel = 3;
    PerUserInitialization = "FALSE";
};

instance of __InstanceProviderRegistration
{
    Provider = $P;
    SupportsGet = "TRUE";
    SupportsPut = "TRUE";
    SupportsDelete = "TRUE";
    SupportsEnumeration = "TRUE";
    QuerySupportLevels = {"WQL:UnarySelect"};
};

instance of __MethodProviderRegistration
{
    Provider = $P;
};


[Abstract, Description (
    "The ManagedSystemElement class is the base class for the system element "
    "hierarchy. Membership Criteria: Any distinguishable component of a "
    "system is a candidate for inclusion in this class.<P>Examples: Software "
    "components, such as files; and devices, such as disk drives and "
    "controllers, and physical components such as chips and cards."):  
    ToSubClass,
 Locale (0x409), UUID ("{8502C517-5FBB-11D2-AAC1-006008C78BC7}")  ] 
class CIM_ManagedSystemElement
{
    [MaxLen (64): ToSubClass , Description (
     "The Caption property is a short textual description (one-line string) "
     "of the object."): ToSubClass , Read: ToSubClass] 
   string Caption ;
    [Description (
     "The Description property provides a textual description of the "
     "object. "): ToSubClass , Read: ToSubClass] 
   string Description ;
    [Description (
     "A datetime value indicating when the object was installed. A lack of a "
     "value does not indicate that the object is not installed."): ToSubClass , 
     MappingStrings {"MIF.DMTF|ComponentID|001.5"}: ToSubClass , Read: ToSubClass] 
   datetime InstallDate ;
    [Description (
     "The Name property defines the label by which the object is known. When "
     "subclassed, the Name property can be overridden to be a Key property."):  
     ToSubClass , Read: ToSubClass] 
   string Name ;
    [Description ("A string indicating the current status of the object."): 
     ToSubClass, ValueMap {"OK", "Error", "Degraded", "Unknown"}: ToSubClass , 
     Read: ToSubClass] 
   string Status ;
};
     
[Abstract, Description (
    "The CIM_LogicalElement class is the base class for all the components "
    "of the system that represent abstract system components.<P>Example: "
    "Profiles, processes, or system capabilities in the form of logical "
    "devices."): ToSubClass,
 Locale (0x409), UUID ("{8502C518-5FBB-11D2-AAC1-006008C78BC7}") ] 
class CIM_LogicalElement:CIM_ManagedSystemElement
{
};

[Abstract, Description (
    "A logical element that contains the information necessary to represent "
    "and manage the functionality provided by a Device and/or "
    "SoftwareFeature. A Service is a general-purpose object to configure and "
    "manage the implementation of functionality. It is not the functionality "
    "itself."): ToSubClass,
 Locale (0x409), UUID ("{8502C527-5FBB-11D2-AAC1-006008C78BC7}") ] 
class CIM_Service:CIM_LogicalElement
{
    [CIM_Key, Read: ToSubClass] 
   string CreationClassName ;
    [Override ("Name"): ToSubClass , Key, Description (
     "The Name property uniquely identifies the Service and provides an "
     "indication of the functionality that is managed. This functionality is "
     "described in more detail in the object's Description property. "): 
     ToSubClass , Read: ToSubClass] 
   string Name ;
    [Description (
     "StartMode is a string value indicating whether the Service is "
     "automatically started by a System, Operating System, etc. or only "
     "started upon request."): ToSubClass , 
     ValueMap {"Automatic", "Manual"}: ToSubClass ,
     Read: ToSubClass] 
   string StartMode ;
    [Description (
     "ServiceStarted is a boolean indicating whether the Service has been "
     "started (TRUE), or stopped (FALSE)."): ToSubClass , Read: ToSubClass] 
   boolean Started ;
    [Propagated ("CIM_System.CreationClassName"): ToSubClass, CIM_Key, 
     Description ("The type name of the system that hosts this service"): 
     ToSubClass , Read: ToSubClass] 
   string SystemCreationClassName ;
    [Propagated ("CIM_System.Name"): ToSubClass, CIM_Key, Description (
     "The name of the system that hosts this service"): ToSubClass , Read: ToSubClass] 
   string SystemName ;
    [Description (
     "The StartService method places the Service in the started state. It "
     "returns an integer value of 0 if the Service was successfully started, "
     "1 if the request is not supported and any other number to indicate an "
     "error."): ToSubClass ] 
   uint32 StartService() ;
    [Description (
     "The StopService method places the Service in the stopped state. It "
     "returns an integer value of 0 if the Service was successfully stopped, "
     "1 if the request is not supported and any other number to indicate an "
     "error."): ToSubClass ] 
   uint32 StopService() ;
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,    
     Description("This class describes a DNS server. Every instance "
          "of this class may be associated with (or more intuitively 'may "
          "contain') one instance of class MicrosoftDNS_Cache, one instance "
          "of class MicrosoftDNS_RootHints and multiple instances of class "
          "MicrosoftDNS_Zone."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
       Locale (0x409), UUID ("{3E9F9B09-AA43-11d2-85DD-0000F8102E5F}") 
    ]
class MicrosoftDNS_Server : CIM_Service
{
        [Override ("Name"): ToSubClass,
         Read: ToSubClass,
         Description("Indicates the Fully Qualified Domain Name or IP "
                  "address of the DNS server."): ToSubClass
        ]
    string Name;

        [Read: ToSubClass,
         Description("Indicates the version of the DNS server."):  
                  ToSubClass
        ]
    uint32 Version;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property controls what packets and events "
                  "are written to the DNS server's debug log. This property "
                  "should be set to "
                  "specific values based on the following algorithm: "
                  "Each policy  "
                  "is assigned a specific value: Query - 1, Notify - 16, "
                  "Update - 32, Non-query transactions - 254, Questions - 256, "
                  "Answers - 512, Send - 4096, Receive - 8192, UDP - 16384, "
                  "TCP - 32768, All packets - 65535, "
                  "Directory Service write transaction - 65536, "
                  "Directory Service update transaction - 131072, "
                  "Full Packets - 16777216, and Write Through - 2147483648. The "
                  "sum of the values corresponding to all the policies to be "
                  "activated is indicated in this property."): ToSubClass,
        Valuemap{"1", "16", "32", "254", "256", "512", "4096", "8192", "16384", 
            "32768", "65535", "65536", "131072", "16777216", "2147483648"}:ToSubClass,
            Values{"Query", "Notify", "Update", "Non-query transactions", "Questions",
                 "Answers", "Send", "Receive", "UDP", "TCP", "All packets", 
                 "NT Directory Service write transaction", 
                 "NT Directory Service update transaction", 
                 "Full Packets", "Write Through"}:ToSubClass
        ]
    uint32 LogLevel;        

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "The file name for the DNS server's debug log. By "
            "the file is system32\\dns\\dns.log. You may change this value. "
            "A relative path path is relative to SystemRoot\\System32. "
            "You may also use absolute paths, but UNC paths are not "
            "supported." ) : ToSubClass
    ]
    string LogFilePath;
    
    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "The size in bytes of the DNS server's debug log." ) :
            ToSubClass
    ]
    uint32 LogFileMaxSize;
    
    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "List of IP addresses used to filter DNS events written "
            " to DNS server's debug log." ) : ToSubClass
    ]
    string LogIPFilterList[];

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates which events the DNS server records "
                  "in the Event Viewer system log."): ToSubClass ,
                 Valuemap {"0", "1", "2", "4"}: ToSubClass , 
                 Values {"None", "Log only errors", "Log only warnings and errors",
                  "Log all events"}: ToSubClass 
        ]
    uint32 EventLogLevel;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the protocols over which "
                  "administrative RPC runs. This property should be set to specific "
                  "value based on the following algorithm: Every protocol to be used "
                  "in RPC is assigned a specific value: None: 0, TCP/IP: 1, Named "
                  "Pipes: 2, LPC: 4. The sum of the values corresponding to all "
                  "the protocols to be used in RPC is indicated in this property.")
                 : ToSubClass
        ]
    sint32 RpcProtocol;
        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the set of eligible characters "
                  "to be used in DNS names."): ToSubClass ,
                 Valuemap {"0", "1", "2", "3"}: ToSubClass ,
                 Values {"Strict RFC (ANSI)", "Non RFC (ANSI)", 
                  "Multibyte (UTF8)", "Any"}: ToSubClass    
               ]
    uint32 NameCheckFlag;
        [Not_NULL, Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the maximum number of host records "
                  "returned in response to an address request. Values between "
                  "5 and 28 are valid."): ToSubClass
        ]
    uint32 AddressAnswerLimit;
        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the interval (in seconds) before "
                  "retrying a recursive lookup. If the RecursionRetry property "
                  "is undefined or zero, retries are made after three "
                  "seconds. Users are discouraged from altering this property. "
                  "However, there are some scenarios where the property "
                  "should be changed.  One example is  when the "
                  "DNS server contacts remote servers over a slow link, and "
                  "the DNS server is retrying BEFORE reception "
                  "of a response from the remote DNS. In this case, raising "
                  "the RecursionRetry timeout to be slightly longer than the "
                  "observed response time from the remote DNS would be "
                  "reasonable."): ToSubClass ,
         Units("Seconds"): ToSubClass
        ]
    uint32 RecursionRetry;
        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the timeout (in seconds) before the "
                  "DNS server gives up recursive query. If the Recursion"
                  "Timeout property is undefined or zero, the DNS "
                  "server gives up after fifteen seconds. In general, the "
                  "fifteen-second timeout is sufficient to allow any "
                  "outstanding response to get back to the DNS server.  Users "
                  "are discouraged from altering this property. One scenario "
                  "where the property should be changed is when the DNS server "
                  "contacts remote servers over a slow link, and the DNS server "
                  "is observed rejecting queries (with SERVER_FAILURE) before "
                  "responses are received.  (Note, that client resolvers also "
                  "retry queries, so careful investigation is required to determine "
                  "that remote responses are really for the query that was timed "
                  "out.) In this case, raising the RecursionTimeout to be "
                  "slightly longer than the observed response time from the "
                  "remote DNS would be reasonable."): ToSubClass ,
             Units("Seconds"): ToSubClass
        ]
    uint32 RecursionTimeout;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the interval (in seconds) to poll "
                  "for changes in DS-integrated zones."): ToSubClass ,
         Units("Seconds"): ToSubClass
        ]
    uint32 DsPollingInterval;

        [Read: ToSubClass, Write: ToSubClass,
         Description("The lifetime (in seconds) of tombstoned "
                  "records in DS-integrated zones."): ToSubClass ,
         Units("Seconds"): ToSubClass
        ]
    uint32 DsTombstoneInterval;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates a maximum time (in seconds) a record from "
                  "a recursive name query may remain in the DNS server cache. "
                  "The DNS server deletes records from the cache when the value "
                  "of this entry expires, even if the value of the TTL field in "
                  "the record is greater. The default value of this property is "
                  "86,400 seconds (1 day)."): ToSubClass ,
         Units("Seconds"): ToSubClass
        ]
    uint32 MaxCacheTTL;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates a maximum time (in seconds) a name error "
                  "result from  a recursive name query may remain in the "
                  "DNS server cache. The DNS server deletes records from "
                  "the cache when the value of this entry expires, even if "
                  "the value of the TTL field in the record is greater. The "
                  "default value of this property is 86,400 seconds "
                  "(1 day)."): ToSubClass ,
         Units("Seconds"): ToSubClass
        ]
    uint32 MaxNegativeCacheTTL;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the port on which the DNS server "
                  "sends UDP queries to other servers. By default, the DNS "
                  "server sends queries on a socket bound to the "
                  "DNS port. Sometimes this situation is NOT desirable.  The  "
                  "most obvious case occurs when an admin firewalls off "
                  "the DNS port, to prevent outside access to the DNS server, "
                  "but still wants the server to be able to contact "
                  "Internet DNS servers to provide name resolution "
                  "for internal clients.  This is also desirable if the DNS "
                  "server is supporting disjoint nets (if true, the "
                  "boolean property, DisjointNets, would be set to TRUE). "
                  "In these cases, setting the SendPort property to "
                  "a non-zero value causes the DNS server to bind to an "
                  "arbitrary port for sending to remote DNS servers." ): ToSubClass
        ]
    uint32 SendPort;

        [Read: ToSubClass, Write: ToSubClass,
         Description( "Timeout in seconds the DNS server will wait for a "
            "successful TCP connection to a remote server when attempting "
            "a zone transfer." ): ToSubClass
        ]
    uint32 XfrConnectTimeout;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the DNS server's initialization method."): 
               ToSubClass ,
             Values {"Uninitialized", "Boot from file", "Boot from registry",
               "Boot from directory and registry"}: ToSubClass
        ]
    uint32 BootMethod;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This UInt32 indicates whether the DNS server "
        "accepts dynamic update requests."): ToSubClass,
        Values {"Do not allow dynamic updates", "Allow unsecure dynamic updates",
         "Allow only secure dynamic updates"}: ToSubClass
        ]
    uint32 AllowUpdate;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This value restricts the type of records "
            "that can be dynamically updated on the server. This parameter "
            "is a further restriction on dynamic updates applied after the "
            "AllowUpdate setting on Server and Zone objects. "
            "Use these values: \"No restrictions\" = 0, \"Do not allow dynamic "
            "updates of SOA records\" = 1, \"Do not allow dynamic updates of NS "
            "records at the zone root\" = 2, \"Do not allow dynamic updates of "
            "NS records not at the zone root (delegation NS records)\" = 4. "
            "Sum these values to determine the setting value. " ): ToSubClass
        ]
    uint32 UpdateOptions;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether there is an "
                  "available DS on the DNS server."): ToSubClass
        ]
    boolean DsAvailable;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property indicates whether the DNS server "
                  "automatically creates standard reverse lookup zones."):
                  ToSubClass
        ]
    boolean DisableAutoReverseZones;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server "
                  "attempts to update its cache entries using data from root "
                  "servers. When a DNS server boots, it needs a list of root "
                  "server 'hints' - NS and A records for the servers - "
                  "historically called the cache file. The Microsoft DNS "
                  "server has a feature to allow it to attempt to "
                  "write back a new cache file based on the responses from "
                  "the root servers."): ToSubClass
        ]
    boolean AutoCacheUpdate;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server does "
                  "NOT do recursive lookups. If set to TRUE, recursive "
                  "lookups are not done."): ToSubClass
        ]
    boolean NoRecursion;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server "
                  "round robins multiple A records."): ToSubClass
        ]
    boolean RoundRobin;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server "
                  "gives priority to the local net address returning A "
                  "records."): ToSubClass
        ]
    boolean LocalNetPriority;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server "
                  "parses zone files strictly. If the StrictFileParsing "
                  "property is undefined or zero, the server will log and "
                  "ignore bad data in the zone file and continue to load. If the "
                  "StrictFileParsing property is non-zero, the server will log "
                  "and fail on zone file errors."): ToSubClass
        ]
    boolean StrictFileParsing;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server does "
                  "wildcarding loosely. If the LooseWildcarding property is "
                  "undefined or zero, the server will follow the wildcarding behavior "
                  "specified in the DNS RFC. In this case, an admin is advised to "
                  "include MX records for all hosts that are not capable of receiving "
                  "mail. If the LooseWildcarding property is non-zero, the server "
                  "seeks out the closest wildcard node. In this case, an admin should "
                  "put MX records at both the zone root and in a wildcard node ('*') "
                  "directly below the zone root. Also, the admin should put self-"
          "referent MX records on hosts, which are to receive their own "
                  "mail."): ToSubClass
        ]
    boolean LooseWildcarding;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property determines the AXFR message format when "
        "sending to non-Microsoft DNS secondaries. If this "
        "property is TRUE, the server will send "
        "transfers to non-Microsoft DNS secondaries in the uncompressed "
        "format. If this property is FALSE, "
        "the server will send all transfers in the fast format."): ToSubClass
        ]
    boolean BindSecondaries;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server writes "
                  "NS and SOA records to the authority section on successful "
                  "response."): 
              ToSubClass
        ]
    boolean WriteAuthorityNS;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property indicates whether queries to delegated "
                  "sub-zones are forwarded."): ToSubClass
        ]
    uint32 ForwardDelegations;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether the DNS server only"
                  "saves records of names that are in the same subtree as the "
                  "server that provided them."): ToSubClass
        ]
    boolean SecureResponses;
        [Read: ToSubClass, Write: ToSubClass,
         Description("This Boolean indicates whether override is allowed "
                  "of the default binding for a socket used to send queries "
                  "to remote DNS servers."): ToSubClass
        ]
    boolean DisjointNets;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This Uint32 indicates which standard primary zones "
            "authoritative for the name of the DNS server must be updated "
            "when the name of the server changes. "
            "The default value of this property is 1."): ToSubClass,
                 Valuemap {"0", "1", "2", "3"}: ToSubClass,
                 Values {
                    "None",
                    "Only those that allow dynamic updates",
                    "Only those that do not allow dynamic updates",
                    "All"}: ToSubClass
        ]
    uint32 AutoConfigFileZones;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Indicates the time interval between two consecutive "
              "scavenging operations performed by the server. Zero value means "
              "that scavenging is not enabled on the server."
              "The default value of this property is 168 hours (7 days)."):
              ToSubClass ,
         Units("Hours"): ToSubClass
        ]
    uint32 ScavengingInterval;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies the value of Refresh Interval to be set for all "
                  "Active Directory-integrated zones created on this server. "
                  "The default value of this property is 168 hours (7 days)."): ToSubClass ,
         Units("Hours"): ToSubClass
        ]
    uint32 DefaultRefreshInterval;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies the value of No-Refresh Interval to be set for all "
                  "Active Directory-integrated zones created on this server. "
                  "The default value of this property is 168 hours (7 days)."): ToSubClass ,
         Units("Hours"): ToSubClass
        ]
    uint32 DefaultNoRefreshInterval;
        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies the value of Enable Scavenging flag to be set for all "
            "Active Directory-integrated zones created on this server. "
            "The default value 0 corresponds to the Disabled scavenging of a zone."): ToSubClass 
        ]
    boolean DefaultAgingState;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies the lifetime in seconds of the cached "
            "information describing the EDNS version supported by other "
            "DNS servers."):
            ToSubClass
        ]
    uint32 EDnsCacheTimeout;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies the behavior of the DNS server with regard to "
            "the EDNS specified in the RFC 2671. If this value is FALSE, "
            "then the DNS server responds to the queries with response "
            "containing OPTs if OPTs are send in the original query, but "
            "doesn't include unsolicited OPTs in queries to other servers."
            "If this value is TRUE then the server always "
            "OPT RRs according to RFC 2671 unless the remote server has"
            "indicated that it does not support EDNS in a prior exchange."): ToSubClass
        ]
    boolean EnableEDnsProbes;

        [Read: ToSubClass, Write: ToSubClass,
         Description("Specifies whether the DNS server includes the DNSSEC "
         "specific RRs, KEY,SIG and NXT, in the response. If this value is "
         "0, then no DNSSEC records are included in response, unless the "
         "query was requesting an RRset of the DNSSEC record type. If this "
         "value is 1, then DNSSEC records are included in response according "
         "to the RFC 2535. If this value is 2, then DNSSEC records are "
         "included in response only if the original client query contained "
         "the OPT RR according to the RFC 2671. If a query was requesting "
         "an RRset of the DNSSEC record type the DNS server will always "
         "respond with such records if they are available."): ToSubClass
        ]
    uint32 EnableDnsSec;

        [Read: ToSubClass,
         Description("This array of strings enumerates the list of the DNS "
                  "server's IP addresses."): ToSubClass
        ]
    string ServerAddresses[];

        [Read: ToSubClass, Write: ToSubClass,
         Description("This array of strings enumerates the list of IP addresses "
                  "on which the DNS server is allowed to receive queries."): 
                  ToSubClass
        ]
    string ListenAddresses[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description(" This array of IP addresses "
            "are the servers to which this DNS server forwards queries "
            "that cannot be resolved with local data." ): 
            ToSubClass
    ]
    string Forwarders[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Indicates how long (in seconds) a DNS server, "
            "forwarding a query to a remote server listed in \"Forwarders\" "
            "will wait for a reply." ): ToSubClass ,
         Units("Seconds"): ToSubClass
    ]
    uint32 ForwardingTimeout;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "A slave server will not attempt recursion "
            "if forwarding fails."): ToSubClass
    ]
    boolean IsSlave;

    [
        Read: ToSubClass,
        Write: ToSubClass,
        Description( "This value is TRUE if support for application "
            "directory partitions is enabled on this server." ): ToSubClass
    ]
    boolean EnableDirectoryPartitionSupport;

    //
    //  Methods
    //

        [Implemented, Description(
        "This method starts the DNS server."): ToSubClass 
        ]
    uint32 StartService();

        [Implemented, Description(
        "This method stops the DNS server."): ToSubClass 
        ]
    uint32 StopService();
    
        [Implemented, Description(
        "This method starts the scavenging of stale records in the zones subjected to scavenging."): ToSubClass 
        ]
    uint32 StartScavenging();

        [Implemented, Description(
        "This method get DS distinguished Name for the zone.") : ToSubClass
        ]
    string GetDistinguishedName();
};


    [
     Schema ("MicrosoftDNS"): ToSubClass ,
       Description("This class represents a Domain in a DNS "
          "hierarchy tree."): ToSubClass,
       Dynamic, Provider("MS_NT_DNS_PROVIDER"),
       Locale (0x409), UUID ("{4E0BD136-AA43-11d2-85DD-0000F8102E5F}") 
    ]
class MicrosoftDNS_Domain : CIM_LogicalElement
{
        [Key, Propagated ("MicrosoftDNS_Server.Name"): ToSubClass,
         Read: ToSubClass,
         Description("Indicates the Fully Qualified Domain Name "
                  "or IP address of the DNS server that contains this domain."): 
                  ToSubClass
        ]
    string DnsServerName;
        [Key, Read: ToSubClass,
         Description("Indicates the Name of the Container (which "
                  "could be a Zone, Cache or RootHints) containing this "
                  "domain. In cases where the Container is a Zone (an "
                  "instance of the MicrosoftDNS_Zone subclass), this property"
                  "contains the fully qualified domain name of the Zone. "
                  "When the Container is the root zone, the string, \".\","
                  "should be used.  In cases where the Container is "
                  "the DNS' cache of resource records (an instance of the "
                  "MicrosoftDNS_Cache subclass), this property is set to the "
                  "string, \"..Cache\".  If the Container is Root Hints (an "
                  "instance of the MicrosoftDNS_RootHints subclass), then this "
                  "property should be set to \"..RootHints\"."): ToSubClass 
        ]
    string ContainerName;
        [Override ("Name"): ToSubClass , Key,
         Read: ToSubClass, 
         Description("This string represents the Fully Qualified Domain Name "
                  "of the domain.  For instances of DNS Cache or Root Hints, "
                  "the strings, \"..Cache\" and \"..Root Hints\" respectively, "
                  "should be used."): ToSubClass
        ]
    string Name;
        [Implemented, Description(
        "This method get DS distinguished Name for the zone.") : ToSubClass
        ]
    string GetDistinguishedName();

};

    [
     Schema ("MicrosoftDNS"): ToSubClass , 
       Description("This class describes a DNS Zone. Every instance of "
          "the class MicrosoftDNS_Zone must be assigned to one and only one DNS "
          "server. Zones may be associated with (or more intuitively 'may "
          "contain') any number of instances of the classes MicrosoftDNS_Domain "
          "or/and MicrosoftDNS_ResourceRecord."): ToSubClass, 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
       Locale (0x409), UUID ("{4E0BD137-AA43-11d2-85DD-0000F8102E5F}")     
    ]
class MicrosoftDNS_Zone : MicrosoftDNS_Domain
{
    [
        Read: ToSubClass, 
        Description( "Indicates the type of the Zone." ): ToSubClass,
        Values
            {
            "Cache", "Primary", "Secondary", "Stub", "Forwarder"
            }: ToSubClass
    ]
    uint32 ZoneType;

    [
        Read: ToSubClass,
        Description( "This property indicates whether the Zone is "
            "stored in Active Directory." ): ToSubClass
    ]
    boolean DsIntegrated;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "This Boolean indicates whether the Zone should "
            "accept dynamic update requests." ): ToSubClass
    ]
    uint32 AllowUpdate;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Indicates the name of the zone file." ): ToSubClass
    ]
    string DataFile;

    [
        Read: ToSubClass, 
        Description( "This property is TRUE if the the WINS record "
              "for the zone will not be replicated through zone "
              "transfer." ): ToSubClass
    ]
    boolean DisableWINSRecordReplication;

    [
        Read: ToSubClass, 
        Description( "This property indicates whether the server will "
              "notify secondaries of any changes to records in the zone. "
              "If set to 1, secondaries are notified."): ToSubClass
    ]
    uint32 Notify;
    
    [
        Read: ToSubClass, 
        Description( "This property indicates whether zone transfer is "
              "allowed - but only to designated secondaries."
              "Designated secondaries are DNS servers whose IP addresses "
              "are listed in the Secondaries array." ): ToSubClass
    ]
    uint32 SecureSecondaries;
    
    [
        Read: ToSubClass,
        Description( "This Boolean indicates whether the Zone is "
              "paused."): ToSubClass
    ]
    boolean Paused;

    [
        Read: ToSubClass,
        Description( "This Boolean indicates whether this copy of the "
              "Zone is expired." ): ToSubClass
    ]
    boolean Shutdown;

    [
        Read: ToSubClass,
        Description( "This property indicates whether the zone is a "
            "reverse lookup zone." ): ToSubClass
    ]
    boolean Reverse;

    [
        Read: ToSubClass,
        Description( "This Boolean indicates whether the Zone was "
            "auto-created by the DNS Server." ): ToSubClass
    ]
    boolean AutoCreated;

    [
        Read: ToSubClass,
        Description( "This Boolean indicates whether the Zone uses "
              "WINS lookup."): ToSubClass
    ]
    boolean UseWins;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description("Specifies the aging and scavenging behavior of "
            "this zone. The "
            "0 value corresponds to Disabled scavenging of the zone. If the "
            "Scavenging of the zone is disabled, the timestamps of the records "
            "in the zone are not refreshed and the records are not subjected "
            "to scavenging. If the value is set to 1, the records are subjected "
            "to scavenging and their timestamps are refreshed when the server "
            "receives the dynamic update request for the records. "
            "For the Active Directory-integrated zones this value is set to "
            "the DefaultAgingState property of the DNS server where the "
            "zone is created. For the standard primary zones the default "
            "value is 0."): ToSubClass
        ]
    boolean Aging;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Specifies the value of Refresh Interval, during which "
            "the records with non-zero timestamp are expected to be refreshed "
            "to remain in the zone. Records that have not been refreshed by "
            "expiration of the Refresh interval could be removed by the next "
            "scavenging performed by a server. This value should never be "
            "less than the longest refresh period of the records registered "
            "in the zone. Too shirt values of this parameter may lead to "
            "removal of valid DNS records. Too large values prolong the "
            "lifetime of the stale records. "
            "This value is set to the DefaultRefreshInterval property of the "
            "DNS server where the zone is created." ): ToSubClass,
         Units( "Hours" ): ToSubClass
    ]
    uint32 RefreshInterval;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Specifies the time interval between the last update "
            "of a record's timestamp and the earliest moment when the timestamp "
            "can be refreshed. During No-Refresh Interval a DNS server "
            "suppresses the refreshes sent to a record. Small values of this "
            "parameter may cause often writes to the zone storage, e.g. Active "
            "Directory. Large values of this parameter prolong lifetime of the "
            "stale DNS records. "
            "This value is set to the DefaultRefreshInterval property of the "
            "DNS server where the zone is created." ): ToSubClass ,
         Units( "Hours" ): ToSubClass
    ]
    uint32 NoRefreshInterval;

    [
        Read: ToSubClass,
        Description(
            "Specifies the time when the server may attempt scavenging the "
            "zone. Even if the zone is configured to enable scavenging the "
            "DNS server will not attempt scavenging this zone until after "
            "this moment."
            "This value is set to the current time plus Refresh Interval of "
            "the zone every time when the zone is loaded, resumed after being "
            "paused, scavenging becomes enabled, Refresh Interval is changed "
            "and dynamic update becomes enabled. This parameter is stored "
            "locally and is not replicated to other copies of the "
            "zone."): ToSubClass ,
         Units("Hours since GMT midnight January 1, 1601"): ToSubClass
        ]
    uint32 AvailForScavengeTime;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "IP addresses of the master DNS servers for this "
            "zone." ): ToSubClass
    ]
    string MasterServers[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Local IP addresses of the master DNS servers for this "
            "zone. If set, these masters over-ride the MasterServers found in "
            "Active Directory." ): ToSubClass
    ]
    string LocalMasterServers[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "This array of strings enumerates the list of "
          "IP addresses of DNS servers, that are allowed to perform scavenging "
          "of the stale records of this zone. If the list is not specified any "
          "primary DNS server authoritative for the zone will be able to "
          "scavenge the zone if other prerequisites are met." ): ToSubClass
    ]
    string ScavengeServers[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "This array of strings enumerates the list of IP "
            "addresses of the DNS servers that are allowed to"
            "receive this zone through zone replication." ): ToSubClass
    ]
    string SecondaryServers[];

    [
        Read: ToSubClass, 
        Description( "This array of strings enumerates the list of IP "
            "addresses of the DNS servers that should be notified of "
            "changes in this zone."): ToSubClass
    ]
    string NotifyServers[];

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "Indicates how long (in seconds) a DNS server, "
            "forwarding a query, for the name under the forward zone, "
            "will wait for resolution from the "
            "forwarder, before attempting to resolve the query "
            "itself. This parameter is applicable to the Forward zones "
            "only." ): ToSubClass ,
         Units( "Seconds" ): ToSubClass
    ]
    uint32 ForwarderTimeout;

    [
        Read: ToSubClass, Write: ToSubClass,
        Description( "This Boolean indicates whether the DNS server acts as "
            "a Slave when resolving the names for the specified forward zone. "
            "This parameter is applicable to the Forward zones only."): ToSubClass
    ]
    boolean ForwarderSlave;

    [
        Read: ToSubClass,
        Description( "The time the SOA serial number was last checked for this "
            "zone in seconds since the start of 1 January 1970 GMT." ): ToSubClass
    ]
    uint32 LastSuccessfulSoaCheck;

    [
        Read: ToSubClass,
        Description( "The time this zone was last transferred from a "
            "master server in seconds since the start of 1 January 1970 "
            "GMT." ): ToSubClass
    ]
    uint32 LastSuccessfulXfr;

    //
    //  Methods
    //


    [
        Implemented, Description( "This method pauses the zone."): ToSubClass 
    ]
    void PauseZone();
    
    [
        Implemented, Description( "This method resumes the zone." ): ToSubClass 
    ]
    void ResumeZone();
    
    [
        Implemented, Description( "This method reloads the zone." ): ToSubClass 
    ]
    void ReloadZone();
    
    [
        Implemented, Description(
            "This method causes the server to check the DNS server to "
            "check the master server of a secondary zone for updates." ): ToSubClass 
    ]
    void ForceRefresh();
    
    [
        Implemented, Description(
            "This method forces an update of the zone from the DS. This "
            "method is only valid for DS-integrated zones." ): ToSubClass 
    ]
    void UpdateFromDS();
    
    [
        Implemented, Description(
            "This method saves the xone's data to persistent storage."): ToSubClass 
    ]
    void WriteBackZone();

    [
        Implemented, Description(
            "This method enables aging for some or all non-NS and non-SOA records "
            "in a zone. If no NodeName is specified all records will be affected "
            "to aging and scavenging. If the NodeName is specified and "
            "ApplyToSubtree is not specified or set to 0, then records at the "
            "specified node will be subjected to aging and scavenging. If the "
            "NodeName is specified and ApplyToSubtree is set to 1, then all "
            "records of the subtree starting at the specified node will be "
            "subjected to aging and scavenging. When this method is used, the "
            "timestamp is set to the current time for all non-NS and non-SOA "
            "resource records with the owner name(s) identified by the input "
            "parameters."): ToSubClass 
    ]
    uint32 AgeAllRecords( 
        [ IN, optional ] string NodeName,
        [ IN, optional ] boolean ApplyToSubtree );

    [
        Static, Implemented, Description(
            "This method creates a new zone." ) : ToSubClass
    ]
    void CreateZone(
        [IN] string ZoneName,
        [IN, Values {"DS integrated", "Primary", "Secondary", "Stub", "Stub - DS integrated", "Forward"}] uint32 ZoneType,
        [IN, optional] string DataFileName,
        [IN, optional] string IpAddr[],
        [IN, optional] string AdminEmailName,
        [OUT] MicrosoftDns_Zone ref RR);

    [
        Implemented, Description( "This changes zone type." ) : ToSubClass
    ]
    void ChangeZoneType(
        [IN, Values {"DS integrated", "Primary", "Secondary", "Stub", "Stub - DS integrated", "Forward"}] uint32 ZoneType,
        [IN, optional] string DataFileName,
        [IN, optional] string IpAddr[],
        [IN, optional] string AdminEmailName,
        [OUT]  MicrosoftDns_Zone ref RR);
    
    [
        Implemented, Description(
            "This method resets the secondary ip address array." ) : ToSubClass
    ]
    void ResetSecondaries(
        [IN] string SecondaryServers[],
        [IN] uint32 SecureSecondaries,
        [IN] string NotifyServers[],
        [IN] uint32 Notify,
        [OUT] MicrosoftDns_Zone ref RR);

    [
        Implemented, Description(
            "This method get DS distinguished Name for the zone." ) : ToSubClass
    ]
    string GetDistinguishedName();

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,
       Description("This class describes a cache existing on a DNS "
          "server. It shouldn't be confused with a Cache file which "
          "contains root hints. This class simplifies visualizing the "
          "containment of DNS objects, rather than representing a "
          "real object. The class, MicrosoftDNS_Cache, is a container for the "
          "resource records cached by the DNS server. Every instance of "
          "the class MicrosoftDNS_Cache must be assigned to one and only one "
          "DNS server. It may be associated with (or more intuitively 'may "
          "contain') any number of instances of the classes, MicrosoftDNS_"
          "Domain and/or MicrosoftDNS_ResourceRecord."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{591E9D38-AA43-11d2-85DD-0000F8102E5F}")
    ]
class MicrosoftDNS_Cache : MicrosoftDNS_Domain
{
         [Implemented, 
        Description(
        "This method clears the DNS server's cache of resource records. "
        ): ToSubClass
        ]
    void ClearCache();

        [Implemented, Description(
        "This method get DS distinguished Name for the zone.") : ToSubClass
        ]
    string GetDistinguishedName();

};


    [
     Schema ("MicrosoftDNS"): ToSubClass ,
         Description("This class describes the Root Hints stored in a "
          "Cache file on a DNS server. This class simplifies visualizing the "
          "containment of DNS objects, rather than representing a real "
          "object. Class MicrosoftDNS_RootHints is a container for the resource "
          "records stored by the DNS server in a Cache file. Every instance "
          "of the class MicrosoftDNS_RootHints must be assigned to one and only "
          "one DNS server. It may be associated with (or more intuitively 'may "
          "contain') any number of instances of class MicrosoftDNS_Resource"
          "Record."): ToSubClass,
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
           Locale (0x409), UUID ("{5F3F688C-AA43-11d2-85DD-0000F8102E5F}") 
    ]
class MicrosoftDNS_RootHints : MicrosoftDNS_Domain
{
        [Implemented, Description(
         "This method writes the Root Hints back to the DNS' Cache file. "
          ): ToSubClass 
        ]
    void WriteBackRootHintDatafile();
        [Implemented, Description(
        "This method get DS distinguished Name for the zone.") : ToSubClass
        ]
    string GetDistinguishedName();

};

    [
       Schema ("MicrosoftDNS"): ToSubClass ,         
       Description("This class represents the general properties of a "
          "DNS Resource Record."): ToSubClass, 
     abstract, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{5F3F688D-AA43-11d2-85DD-0000F8102E5F}") 
    ]
class MicrosoftDNS_ResourceRecord : CIM_LogicalElement
{
        [Key, Propagated ("MicrosoftDNS_Domain.DnsServerName"): ToSubClass,
         Read: ToSubClass,
         Description("Indicates the Fully Qualified Domain Name or "
                  "IP address of the DNS server that contains this Resource "
                  "Record."): ToSubClass
        ]
    string DnsServerName;

        [Key, Propagated("MicrosoftDNS_Domain.ContainerName"): ToSubClass,
         Read: ToSubClass, 
         Description("Indicates the name of the Container for "
                  "the Zone, Cache or Root Hints instance which contains this "
                  "Resource Record"): ToSubClass
        ]
    string ContainerName;

        [Key, Propagated ("MicrosoftDNS_Domain.Name"): ToSubClass,    
             Read: ToSubClass, 
         Description("This string represents the Fully Qualified Domain Name of "
                  "the Domain which contains this Resource Record. This property "
                  "may contain the strings, \"..Cache\" or \"..RootHints\", if the "
                  "DNS' internal cache or Root Hints (respectively) contain this "
                  "Resource Record."): ToSubClass
        ]
    string DomainName;

        [Key, Read: ToSubClass,
         Description ("The owner name for the Resource Record."): ToSubClass
        ]
    string OwnerName;

        [Key, Read: ToSubClass, 
         Description("This string represents the class of the Resource "
                  "Record."): ToSubClass,
             Valuemap {"1", "2", "3", "4"}: ToSubClass,
             Values {"IN (Internet)", "CS (CSNET)", "CH (CHAOS)",
                  "HS (Hesiod)"}: ToSubClass
        ]
    uint16 RecordClass=1;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property indicates how long (in seconds) the "
                  "Resource Record can be cached by a DNS resolver."): ToSubClass,
                 Units ("Seconds"): ToSubClass
        ]
    uint32 TTL;

        [Read: ToSubClass, Write: ToSubClass,
         Description("This property indicates the time moment, when the record "
            "was refreshed last time. The zero value means that the record is "
            "not subjected to aging and scavenging. To disable aging and "
            "scavenging of this record set this value to zero. To enable "
            "record's aging and scavenging use AgeAllRecords method defined "
            "under the MicrosoftDNS_Zone class."): ToSubClass,
                 Units ("Hours since GMT midnight January 1, 1601"): ToSubClass
        ]
    uint32 Timestamp;

        [Key, Read: ToSubClass, 
         Description("This string represents the Resource Record data."): 
                  ToSubClass
        ]
    string RecordData;

        [Read: ToSubClass, 
         Description("This string represents the entire Resource Record."): 
                  ToSubClass
        ]
    string TextRepresentation;

        [Static, Implemented, Description(
         "This method parses the resource record in the TextRepresentation "
                 "string, and along with the input DNS server and Container names, "
                 "defines and instantiates a ResourceRecord object. The method "
                 "returns a reference to the new object as an output parameter."
                 ): ToSubClass
        ]
    void CreateInstanceFromTextRepresentation(
        [IN] string DnsServerName,
        [IN] string ContainerName, 
        [IN] string TextRepresentation,
        [OUT] MicrosoftDNS_ResourceRecord ref RR );  
        
        [Static, Implemented, Description(
            "This method to retrieve an existing instance of the MicrosoftDns_ResourceRecord "
            "subclass, represented by the TextRepresentation string along with Dns Server "
            "and container name." ): ToSubClass
        ]
    void GetObjectByTextRepresentation(
        [IN] string DnsServerName,
        [IN] string ContainerName,
        [IN] string TextRepresentation,
        [OUT] MicrosoftDns_ResourceRecord RR);

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,
       Description ("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type A record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{1A2BC2E6-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_AType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The IP address of the Host (A) record."): ToSubClass
        ]
    string IPAddress;

        [Implemented, static, Description(
         "This method instantiates an 'A' Type of Resource Record based on "
                 "the data in the method's input parameters: the record's DNS Server "
                 "Name, Container Name, Owner Name, class (default = IN), 'time to "
                 "live' value and the Host's IP address. It returns a reference to "
                 "the new object as an output parameter."): 
                 ToSubClass
        ]
    void CreateInstanceFromPropertyData(
        [IN] string DnsServerName,
        [IN] string ContainerName, 
        [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] string IPAddress, 
        [OUT] MicrosoftDNS_AType ref RR);  

        [Implemented, Description(
         "This method updates the TTL and IP address to the values specified "
         "as the input parameters of this method. If a new value for some "
         "parameter is not specified, then the current value for this parameter "
         "is not changed. The method returns a reference to the modified "
         "object as an output parameter."): ToSubClass
        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string IPAddress, 
        [OUT] MicrosoftDNS_AType ref RR );  
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,
       Description ("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type SOA record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{47B8D066-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_SOAType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass ,
         Description("The serial number of the SOA record."): ToSubClass
        ]
    uint32 SerialNumber;
        [Read: ToSubClass ,
         Description("The primary DNS server having authority for the zone "
                  "to which this record belongs."): ToSubClass
        ]
    string PrimaryServer;
        [Read: ToSubClass ,
         Description("The 'responsible party' for the zone to which this "
                  "record belongs."): ToSubClass
        ]
    string ResponsibleParty;
        [Read: ToSubClass ,
         Description("The time interval (in seconds) before the zone, "
                  "containing this record, should be refreshed."): ToSubClass ,
         Units ("Seconds"): ToSubClass
        ]
    uint32 RefreshInterval;
        [Read: ToSubClass ,
         Description("The time interval (in seconds) that should elapse before "
                  "retrying a failed refresh of the zone to which this record belongs."):
                  ToSubClass ,
             Units ("Seconds"): ToSubClass
        ]
    uint32 RetryDelay;
        [Read: ToSubClass ,
         Description("The upper limit on the time interval (in seconds) that "
                  "can elapse before the zone, to which this record belongs, is no "
              "longer authoritative."): ToSubClass ,
                 Units ("Seconds"): ToSubClass
        ]
    uint32 ExpireLimit;
        [Read: ToSubClass ,
         Description("The lower limit on the time interval (in seconds) that a "
                  "DNS server or Caching resolver are allowed to cache any resource "
                  "record from the zone, to which this record belongs."): ToSubClass ,
                 Units ("Seconds"): ToSubClass
        ]
    uint32 MinimumTTL;
        [Implemented, Description(
         "This method updates the TTL, SOA Serial Number, Primary Server, "
          "Responsible Party, Refresh Interval, Retry Delay, Expire Limit and "
          "Minimum TTL (for the zone) to the values specified as the input "
          "parameters of this method. If a new value for some parameter is not "
          "specified, then the current value for this parameter is not changed. "
          "The method returns a reference to the modified object as an output "
          "parameter."): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint32 SerialNumber, 
        [IN, optional] string PrimaryServer,
        [IN, optional] string ResponsibleParty, 
        [IN, optional] uint32 RefreshInterval, 
        [IN, optional] uint32 RetryDelay, 
        [IN, optional] uint32 ExpireLimit, 
        [IN, optional] uint32 MinimumTTL, 
        [OUT] MicrosoftDNS_SOAType ref RR);  

 

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type PTR record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{567E21F9-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_PTRType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The Fully Qualified Domain Name of the PTR record Data."):
                  ToSubClass
        ]
    string PTRDomainName;
        [Implemented,static, Description(
         "This method instantiates a 'PTR' Type of Resource Record based on "
                 "the data in the method's input parameters: the record's DNS Server "
                 "Name, Container Name, Owner Name, class (default = IN), 'time to "
                 "live' value and the FQDN of the PTR record. It returns a "
                 "reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData(
        [IN] string DnsServerName,
        [IN] string ContainerName, 
        [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] string PTRDomainName, 
        [OUT] MicrosoftDNS_PTRType ref RR);  
        
        [Implemented, Description(
        "This method updates the TTL and PTR Domain Name to the values "
        "specified as the input parameters of this method. If a new value "
        "for some parameter is not specified, then the current value for this "
        "parameter IS not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string PTRDomainName, 
        [OUT] MicrosoftDNS_PTRType ref RR);  

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type NS record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{3F655A18-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_NSType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A host which should be authoritative for the domain, "
                 "specified in record's owner."): ToSubClass
               ]
    string NSHost;
        [Implemented, static, Description(
         "This method instantiates an 'NS' Type of Resource Record based on "
                 "the data in the method's input parameters: the record's DNS Server "
                 "Name, Container Name, Owner Name, class (default = IN), 'time to "
                 "live' value and the host with authority for the domain. It returns "
                 "a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string NSHost, 
        [OUT] MicrosoftDNS_NSType ref RR);  

        [Implemented, Description(
        "This method updates the TTL and NS Host to the values specified as the "
        "input parameters of this method. If a new value for some parameter is "
        "not specified, then the current value for this parameter IS not changed. "
        "The method returns a reference to the modified object as an output "
        "parameter. "): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string NSHost, 
        [OUT] MicrosoftDNS_NSType ref RR);  

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type CNAME record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{47B8D065-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_CNAMEType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The canonical or primary name for the owner "
                  "of the CNAME record."): ToSubClass
        ]
    string PrimaryName;
        [Implemented, static, Description(
         "This method instantiates a 'CNAME' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value and the primary name of the CNAME record. It "
                 "returns a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string PrimaryName, 
        [OUT] MicrosoftDNS_CNAMEType ref RR);
          
        [Implemented, Description(
         "This method updates the TTL and Primary Name to the values specified "
         "as the input parameters of this method. If a new value for some "
         "parameter is not specified, then the current value for this parameter "
         "is not changed. The method returns a reference to the modified object "
         "as an output parameter."): ToSubClass
        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string PrimaryName, 
        [OUT] MicrosoftDNS_CNAMEType ref RR);  

};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MB record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{47B8D067-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MBType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "of the mailbox specified in the record's Owner Name."): ToSubClass
        ]
    string MBHost;
        [Implemented, static, Description(
         "This method instantiates an 'MB' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the mailbox, class "
                 "(default = IN), 'time to live' value and the mailbox host. It "
                 "returns a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string MBHost, 
        [OUT] MicrosoftDNS_MBType ref RR);

        [Implemented, Description(
        "This method updates the TTL and MB Host to the values specified as "
        "the input parameters of this method. If a new value for some parameter "
        "is not specified, then the current value for this parameter is not "
        "changed. The method returns a reference to the modified object as an "
        "output parameter."): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN] string MBHost, 
        [OUT] MicrosoftDNS_MBType ref RR);  
  
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MD record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{3F655A19-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MDType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "which has a mail agent which should be able to deliver mail for "
                 "the specified domain."): ToSubClass
        ]
    string MDHost;
        [Implemented, static, Description(
         "This method instantiates an 'MD' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the domain, class "
                 "(default = IN), 'time to live' value and the host of the mail "
                 "agent. It returns a reference to the new object as an output "
                 "parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string MDHost, 
        [OUT] MicrosoftDNS_MDType ref RR);  

        [Implemented, Description(
        "This method updates the TTL and MD Host to the values specified "
        "as the input parameters of this method. If a new value for some "
        "parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass
        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string MDHost, 
        [OUT] MicrosoftDNS_MDType ref RR);
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MF record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{47B8D064-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MFType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "which has a mail agent which will accept mail for forwarding to "
                 "the specified domain."): ToSubClass
        ]
    string MFHost;
        [Implemented, static, Description(
         "This method instantiates an 'MF' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the domain, class "
                 "(default = IN), 'time to live' value and the host of the mail "
                 "agent. It returns a reference to the new object as an output "
                 "parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string MFHost, 
        [OUT] MicrosoftDNS_MFType ref RR); 

        [Implemented, Description(
        "This method updates the TTL and MF Host to the values specified "
        "as the input parameters of this method. If a new value for some "
        "parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter. "): ToSubClass
        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string MFHost, 
        [OUT] MicrosoftDNS_MFType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MG record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{4FFDF894-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MGType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a "
                 "mailbox which is a member of the mail group specified by the "
                 "record's owner name."): ToSubClass
        ]
    string MGMailbox;
        [Implemented, static, Description(
         "This method instantiates an 'MG' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the mail group, class "
                 "(default = IN), 'time to live' value and the mailbox name. It "
                 "returns a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string MGMailbox, 
        [OUT] MicrosoftDNS_MGType ref RR);  
        
        [Implemented, Description(
        "This method updates the TTL and MG Mailbox to the values specified "
        "as the input parameters of this method. If a new value for some "
        "parameter is not specified, then the current value for this parameter "
        "is not changed. The method returns a reference to the modified "
        "object as an output parameter. "): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string MGMailbox, 
        [OUT] MicrosoftDNS_MGType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MR record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{4FFDF895-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MRType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a "
                 "mailbox which is the proper rename of the mailbox specified "
                 "in the record's Owner Name."): ToSubClass
        ]
    string MRMailbox;
        [Implemented, static, Description(
         "This method instantiates an 'MR' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the mailbox, class "
                 "(default = IN), 'time to live' value and the mailbox rename. It "
                 "returns a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName,
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string MRMailbox, 
        [OUT] MicrosoftDNS_MRType ref RR);  

        [Implemented, Description(
        "This method updates the TTL and MR Mailbox to the values "
        "specified as the input parameters of this method. If a new value "
        "for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void Modify(
        [IN, optional] uint32 TTL, 
        [IN] string MRMailbox, 
        [OUT] MicrosoftDNS_MRType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MINFO record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{5CA876B4-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MINFOType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a "
                 "mailbox which is responsible for the mailing list or mailbox "
                 "specified in the record's Owner Name."): ToSubClass
        ]
    string ResponsibleMailbox;
        [Read: ToSubClass ,
         Description("A Fully Qualified Domain Name which specifies a "
                 "mailbox which is to receive error messages related to the mailing "
                 "list or mailbox specified by the owner name of the MINFO record."):
         ToSubClass
        ]
    string ErrorMailbox;
        [Implemented, static, Description(
         "This method instantiates an 'MINFO' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name of the mail list/box, "
                 "class (default = IN), 'time to live' value and the responsible "
                 "and error mailboxes. It returns a reference to the new object "
                 "as an output parameter."): 
                 ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string ResponsibleMailbox, 
        [IN] string ErrorMailbox, [OUT] MicrosoftDNS_MINFOType ref RR);  

        [Implemented, Description(
        "This method updates the TTL, Responsible Mailbox and Error Mailbox "
        "to the values specified as the input parameters of this method. If "
        "a new value for some parameter is not specified, then the current "
        "value for this parameter is not changed. The method returns a "
        "reference to the modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string ResponsibleMailbox, 
        [IN, optional] string ErrorMailbox,
        [OUT] MicrosoftDNS_MINFOType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type RP record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{835AC174-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_RPType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name that specifies the "
                 "mailbox for the responsible person."): ToSubClass
        ]
    string RPMailbox;
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name for which TXT RR's "
                 "exist."): ToSubClass
        ]
    string TXTDomainName;
        [Implemented, static, Description(
         "This method instantiates an 'RP' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/responsible person Name, "
                 "class (default = IN), 'time to live' value and the domain names "
                 "for the person's mailbox and TXT RR locations. It returns a "
                 "reference to the new object as an output parameter."): 
             ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string RPMailbox, 
        [IN] string TXTDomainName, [OUT] MicrosoftDNS_RPType ref RR);  

        [Implemented, Description(
        "This method updates the TTL, RP Mailbox and TXT Domain Name to the "
        "values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value "
        "for this parameter is not changed. The method returns a reference "
        "to the modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string RPMailbox, 
        [IN, optional] string TXTDomainName,
        [OUT] MicrosoftDNS_RPType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type MX record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{835AC172-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_MXType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The preference given to this RR among others "
                  "at the same owner.  Lower values are preferred."): ToSubClass
        ]
    uint16 Preference;

        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "willing to act as a mail exchange for the owner name."): ToSubClass
        ]
    string MailExchange;

        [Implemented, static, Description(
         "This method instantiates an 'MX' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, record preference and host name willing "
                 "to be a mail exchange. It returns a reference to the new "
                 "object as an output parameter."): 
             ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] uint16 Preference, 
        [IN] string MailExchange, [OUT] MicrosoftDNS_MXType ref RR);  

        [Implemented, Description(
        "This method updates the TTL, Preference and Mail Exchange to the "
        "values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value "
        "for this parameter is not changed. The method returns a reference "
        "to the modified object as an output parameter."): ToSubClass
        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Preference, 
        [IN, optional] string MailExchange,
        [OUT] MicrosoftDNS_MXType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type AFSDB record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{8AEF7B9E-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_AFSDBType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("Subtype of the host AFS server. For subtype 1, "
                  "the host has an AFS version 3.0 Volume Location Server for "
                  "the named AFS cell.  In the case of subtype 2, the host has "
                  "an authenticated name server holding the cell-root directory "
                  "node for the named DCE/NCA cell."): ToSubClass, 
         ValueMap {"1", "2"}: ToSubClass
        ]
    uint16 Subtype;
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "that has a server for the AFS cell specified in owner name."):
         ToSubClass
        ]
    string ServerName;
        [Implemented, static, Description(
         "This method instantiates an 'AFSDB' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/cell Name, class (default = "
                 "IN), 'time to live' value, and host AFS server subtype and name. "
                 "It returns a reference to the new object as an output parameter."
                 ): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] uint16 Subtype, [IN] string ServerName, 
        [OUT] MicrosoftDNS_AFSDBType ref RR); 

        [Implemented, Description(
        "This method updates the TTL, Subtype and Server Name to the values "
        "specified as the input parameters of this method. If a new value "
        "for some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Subtype, 
        [IN, optional] string ServerName,
        [OUT] MicrosoftDNS_AFSDBType ref RR);  
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type RT record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{913D93A0-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_RTType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The preference given to this RR among others "
                  "at the same owner.  Lower values are preferred."): ToSubClass
        ]
    uint16 Preference;
        [Read: ToSubClass , 
         Description("A Fully Qualified Domain Name which specifies a host "
                 "which will serve as an intermediate in reaching the host "
                 "specified by owner."): ToSubClass
        ]
    string IntermediateHost;
        [Implemented, static, Description(
         "This method instantiates an 'RT' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/host Name, class (default = "
                 "IN), 'time to live' value, record preference and intermediate "
                 "host name. It returns a reference to the new object as an output "
                 "parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] uint16 Preference, 
        [IN] string IntermediateHost, [OUT] MicrosoftDNS_RTType ref RR);  

        [Implemented, Description(
        "This method updates the TTL, Preference and Intermediate Host to "
        "the values specified as the input parameters of this method. If a "
        "new value for some parameter is not specified, then the current "
        "value for this parameter is not changed. The method returns a "
        "reference to the modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Preference, 
        [IN, optional] string IntermediateHost,
        [OUT] MicrosoftDNS_RTType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type HINFO record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{567E21FA-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_HINFOType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The CPU type of the owner of the record."): 
              ToSubClass
        ]
    string CPU;
        [Read: ToSubClass ,
         Description("The operating system type of the owner."): ToSubClass
        ]
    string OS;
        [Implemented, static, Description(
         "This method instantiates an 'HINFO' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, and the host's CPU and OS types. It returns "
                 "a reference to the new object as an output parameter."
                 ): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string CPU, [IN] string OS, 
        [OUT] MicrosoftDNS_HINFOType ref RR); 

        [Implemented, Description(
        "This method updates the TTL, CPU and OS to the values specified as "
        "the input parameters of this method. If a new value for some "
        "parameter is not specified, then the current value for this parameter "
        "is not changed. The method returns a reference to the modified object "
        "as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string CPU, 
        [IN, optional] string OS,
        [OUT] MicrosoftDNS_HINFOType ref RR);  
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type ISDN record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{8AEF7BA0-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_ISDNType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The ISDN number and DDI of the record's owner."): 
              ToSubClass
        ]
    string ISDNNumber;
        [Read: ToSubClass ,
         Description("The subaddress of the owner, if defined."): ToSubClass
        ]
    string SubAddress;
        [Implemented, static, Description(
         "This method instantiates an 'ISDN' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, and the ISDN number and subaddress of the "
                 "owner. It returns a reference to the new object as an output "
                 "parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string ISDNNumber, [IN] string SubAddress, 
        [OUT] MicrosoftDNS_ISDNType ref RR);

        [Implemented, Description(
        "This method updates the TTL, ISDN Number and SubAddress to the values "
        "specified as the input parameters of this method. If a new value for "
        "some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string ISDNNumber, 
        [IN, optional] string SubAddress,
        [OUT] MicrosoftDNS_ISDNType ref RR);   
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type TXT record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{835AC173-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_TXTType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("Descriptive text whose semantics depend on the owner "
                  "domain."): ToSubClass
        ]
    string DescriptiveText;
        [Implemented, static, Description(
         "This method instantiates a 'TXT' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, and the record's text. It returns a "
                 "reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string DescriptiveText, 
        [OUT] MicrosoftDNS_TXTType ref RR);  

        [Implemented, Description(
        "This method updates the TTL and Descriptive Text to the values "
        "specified as the input parameters of this method. If a new value for "
        "some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN] string DescriptiveText, 
        [OUT] MicrosoftDNS_TXTType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type X25 record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{8AEF7B9F-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_X25Type : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("PSDN address of the record's owner."): ToSubClass
        ]
    string PSDNAddress;
        [Implemented, static, Description(
         "This method instantiates an 'X25' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, and the PSDN address. It returns a "
                 "reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string PSDNAddress, 
        [OUT] MicrosoftDNS_X25Type ref RR); 

        [Implemented, Description(
        "This method updates the TTL and PSDN Address to the values "
        "specified as the input parameters of this method. If a new value for "
        "some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string PSDNAddress, 
        [OUT] MicrosoftDNS_X25Type ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type WKS record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{567E21F8-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_WKSType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A 32 bit Internet address for the record's owner."):
              ToSubClass
         ]
    string InternetAddress;
        [Read: ToSubClass ,
         Description("A string representing the IP protocol for this record. Values "
                    "included 'udp' or 'tcp'."): ToSubClass
        ]
    string IPProtocol;
        [Read: ToSubClass ,
         Description("A string that contains all the services used by the "
                    "Well Known Service (WKS) record."): ToSubClass
        ]
    string Services;
        [Implemented, static, Description(
         "This method instantiates a 'WKS' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner Name, class (default = IN), "
                 "'time to live' value, and the owner's Internet Address, IP "
                 "protocol and port bit mask. It returns a reference to the new "
                 "object as an output parameter."): 
                 ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, 
        [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] string InternetAddress, 
        [IN] string IPProtocol,
        [IN] string Services, 
        [OUT] MicrosoftDNS_WKSType ref RR);  

        [Implemented, Description(
        "This method updates the TTL, Internet Address, IP Protocol and Services"
        "to the values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint32 InternetAddress, 
        [IN, optional] uint8 IPProtocol, 
        [IN, optional] uint8 Services,
        [OUT] MicrosoftDNS_WKSType ref RR);  
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type AAAA record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{913D93A1-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_AAAAType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The AAAA address for a IPv6 host."): ToSubClass
        ]
    string IPv6Address;
        [Implemented, static, Description(
         "This method instantiates an 'AAAA' Type of Resource Record based "
        "on the data in the method's input parameters: the record's DNS "
        "Server Name, Container Name, Owner/host Name, class (default = "
        "IN), 'time to live' value, and the IPv6 address. It returns a "
        "reference to the new object as an output parameter.")
        : ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, [IN] string IPv6Address, 
        [OUT] MicrosoftDNS_AAAAType ref RR);  
        
        [Implemented, Description(
        "This method updates the TTL and IPv6 Address to the values "
        "specified as the input parameters of this method. If a new value for "
        "some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] string IPv6Address, 
        [OUT] MicrosoftDNS_AAAAType ref RR);
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type SRV record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{A9A68712-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_SRVType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A priority of the target host specified in owner "
                  "name. Lower numbers imply higher priorities."): ToSubClass
        ]
    uint16 Priority;
        [Read: ToSubClass , 
         Description("A weight of the target host. This is useful when "
                  "selecting among hosts that have the same priority. The chances "
                  "of using this host should be proportional to its weight."): 
              ToSubClass
        ]
    uint16 Weight;
        [Read: ToSubClass ,
         Description("A port on the target host of a protocol service."):
              ToSubClass
        ]
    uint16 Port;
        [Read: ToSubClass , 
             Description("A Fully Qualified Domain Name of the target host. A "
                 "target of \".\" means that the service is decidedly not available "
                 "at this domain."): ToSubClass
        ]
    string DomainName;
        [Implemented, static, Description(
         "This method instantiates an 'SRV' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/target Name, class (default = "
               "IN), 'time to live' value, and target host's priority, weight, "
                 "port and domain name. It returns a reference to the new object "
                 "as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,     
        [IN, optional] uint32 TTL, [IN] uint16 Priority, [IN] uint16 Weight, 
        [IN] uint16 Port, [IN] string DomainName, [OUT] MicrosoftDNS_SRVType ref RR); 
        
        [Implemented, Description(
        "This method updates the TTL, Priority, Weight, Port, and Domain Name "
        "to the values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Priority, 
        [IN, optional] uint16 Weight, 
        [IN, optional] uint16 Port, 
        [IN, optional] string DomainName, 
        [OUT] MicrosoftDNS_SRVType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type ATMA record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{A9A68713-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_ATMAType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("The ATM address format. Two possible values "
                  "for FORMAT are: 0 indicating ATM End System Address (AESA) "
                  "format and 1 indicating E.164 format."): ToSubClass, 
         Values {"AESA", "E.164"}: ToSubClass
        ]
        uint16 Format;
        [Read: ToSubClass ,
         Description("A variable length string of octets containing the "
                  "ATM address of the node/owner to which this RR pertains. The "
                  "first four bytes of the array are used to store the size of the "
                  "octet string. The most significant byte is stored in byte 0."): 
          ToSubClass
        ]
        string ATMAddress; 
        [Implemented, static, Description(
         "This method instantiates an 'ATMA' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/node Name, class (default = "
             "IN), 'time to live' value, and ATM format and address. It returns "
                 "a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] uint16 Format, 
        [IN] string ATMAddress, 
        [OUT] MicrosoftDNS_ATMAType ref RR);  
        
        [Implemented, Description(
        "This method updates the TTL, Format and ATMA Address to the values "
        "specified as the input parameters of this method. If a new value for "
        "some parameter is not specified, then the current value for this "
        "parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass
        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Format, 
        [IN, optional] string ATMAddress, 
        [OUT] MicrosoftDNS_ATMAType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type WINS record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{A9A68714-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_WINSType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("A WINS mapping flag that specifies whether the record "
        "must be included into the zone replication. It may have only two "
        "values: 0x80000000 and 0x00010000 corresponding to the replication "
        "and no-replication (local record) flags, respectively."): ToSubClass,
        ValueMap {"0x80000000", "0x00010000"}: ToSubClass

        ]
    uint32 MappingFlag;
        [Read: ToSubClass ,
         Description("How long (in seconds) a DNS server, using WINS Lookup, "
                  "waits before giving up."): ToSubClass ,
             Units ("Seconds"): ToSubClass
        ]
    uint32 LookupTimeout;
        [Read: ToSubClass ,
         Description("How long (in seconds) a DNS server, using WINS Lookup, "
              "may cache the WINS server's response."): ToSubClass ,
             Units ("Seconds"): ToSubClass
        ]
    uint32 CacheTimeout;
        [Read: ToSubClass ,
         Description("A comma separated list of IP addresses of WINS servers "
                  "to be addressed in a WINS Lookups."): ToSubClass
        ]
    string WinsServers;
        [Implemented, static, Description(
        "This method instantiates a 'WINS' Type of Resource Record based "
        "on the data in the method's input parameters: the record's DNS "
        "Server Name, Container Name, Owner Name, class (default = "
        "IN), 'time to live' value, and WINS mapping flag, lookup timeout, "
        "cache timeout and list of IP addresses for lookup. It returns "
        "a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] uint32 MappingFlag, 
        [IN] uint32 LookupTimeout, 
        [IN] uint32 CacheTimeout, 
        [IN] string WinsServers, 
        [OUT] MicrosoftDNS_WINSType ref RR); 
        
        [Implemented, Description(
         "This method updates the TTL, Mapping Flag, Lookup Timeout, Cache Timeout "
         "and Wins Servers to the values specified as the input parameters of this "
         "method. If a new value for some parameter is not specified, then the "
         "current value for this parameter is not changed. The method returns a "
         "reference to the modified object as an output parameter."): ToSubClass
        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint32 MappingFlag, 
        [IN, optional] uint32 LookupTimeout, 
        [IN, optional] uint32 CacheTimeout, 
        [IN, optional] string WinsServers, 
        [OUT] MicrosoftDNS_WINSType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type WINSR record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{A9A68715-B6EA-11d2-85E5-0000F8102E5F}") 
    ]
class MicrosoftDNS_WINSRType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
        Description("A WINSR mapping flag that specifies whether the record "
        "must be included into the zone replication. It may have only two "
        "values: 0x80000000 and 0x00010000 corresponding to the replication "
        "and no-replication (local record) flags, respectively."): ToSubClass,
        ValueMap {"0x80000000", "0x00010000"}: ToSubClass

        ]
    uint32 MappingFlag;
        [Read: ToSubClass ,
         Description("How long (in seconds) a DNS server, using WINS Reverse "
          "Lookup, waits before giving up."): ToSubClass ,
             Units ("Seconds"): ToSubClass
        ]
    uint32 LookupTimeout;
        [Read: ToSubClass ,
         Description("How long (in seconds) a DNS server, using WINS Lookup, "
              "may cache the WINS server's response."): ToSubClass ,
             Units ("Seconds"): ToSubClass
        ]
    uint32 CacheTimeout;
        [Read: ToSubClass ,
         Description("A domain name to append to returned NetBIOS names."):
                  ToSubClass
        ]
    string ResultDomain;
        [Implemented, static, Description(
        "This method instantiates a 'WINSR' Type of Resource Record based "
        "on the data in the method's input parameters: the record's DNS "
        "Server Name, Container Name, Owner Name, class (default = "
        "IN), 'time to live' value, and WINS mapping flag, reverse lookup "
        "timeout, WINS cache timeout and domain name to append. It returns "
        "a reference to the new object as an output parameter.")
        : ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,   
        [IN, optional] uint32 TTL, 
        [IN] uint32 MappingFlag, 
        [IN] uint32 LookupTimeout, 
        [IN] uint32 CacheTimeout, 
        [IN] string ResultDomain, 
        [OUT] MicrosoftDNS_WINSRType ref RR); 
        
        
        [Implemented, Description(
         "This method updates the TTL, Mapping Flag, Lookup Timeout, Cache Timeout "
         "and Result Domain to the values specified as the input parameters of this "
         "method. If a new value for some parameter is not specified, then the "
         "current value for this parameter is not changed. The method returns a "
         "reference to the modified object as an output parameter"): ToSubClass
        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint32 MappingFlag, 
        [IN, optional] uint32 LookupTimeout, 
        [IN, optional] uint32 CacheTimeout, 
        [IN, optional] string ResultDomain, 
        [OUT] MicrosoftDNS_WINSRType ref RR); 
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type KEY record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{E4DEB050-B3FA-4EEC-BF2E-AA93CD000373}") 
    ]
class MicrosoftDNS_KEYType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("Set of flags described in RFC 2535."): ToSubClass
        ]
    uint16 Flags;
        [Read: ToSubClass , 
         Description("Protocol for which the key specified in this record "
                  "can be used. The assigned values include 1-5 and map to the "
                  "protocols as follows. 1-TLS, 2-email, 3-dnssec, 4-IPSEC, 255-All "): 
              ToSubClass
        ]
    uint16 Protocol;
        [Read: ToSubClass ,
         Description("Algorithm that can be used with the key specified in "
                  "this record. The assigned values include 1-4 and map to the algorithms "
                  "as follows. 1-RSA/MD5 [RFC 2537], 2-Diffie-Hellman [RFC 2539], "
                  "3-DSA [RFC 2536], 4- elliptic curve crypto "):
              ToSubClass
        ]
    uint16 Algorithm;
        [Read: ToSubClass , 
             Description("Public key is represented in base 64 as described in the "
                 "RFC 2535, Appendix A. "): ToSubClass
        ]
    string PublicKey;
        [Implemented, static, Description(
         "This method instantiates a 'KEY' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/target Name, class (default = "
               "IN), 'time to live' value, and Flags, Protocol, Algorithm and "
                 "PublicKey. It returns a reference to the new object "
                 "as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,     
        [IN, optional] uint32 TTL, [IN] uint16 Flags, [IN] uint16 Protocol, 
        [IN] uint16 Algorithm, [IN] string PublicKey, [OUT] MicrosoftDNS_KEYType ref RR); 
        
        [Implemented, Description(
        "This method updates the TTL, Flags, Protocol, Algorithm and PublicKey "
        "to the values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN, optional] uint16 Flags, 
        [IN, optional] uint16 Protocol,  
        [IN, optional] uint16 Algorithm,
        [IN, optional] string PublicKey, 
        [OUT] MicrosoftDNS_KEYType ref RR); 
};



    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type SIG record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{564EB73D-B8A9-4517-B721-AB84BD9B2D}") 
    ]
class MicrosoftDNS_SIGType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass, 
         Description("Type of the RR covered by this SIG."): ToSubClass
        ]
    uint16 TypeCovered;
        [Read: ToSubClass,
         Description("Algorithm that can be used with the key specified in "
                  "this record. The assigned values include 1-4 and map to the algorithms "
                  "as follows. 1-RSA/MD5 [RFC 2537], 2-Diffie-Hellman [RFC 2539], "
                  "3-DSA [RFC 2536], 4- elliptic curve crypto "):
              ToSubClass
        ]
    uint16 Algorithm;
        [Read: ToSubClass,
              Description("The \"labels\" octet is an unsigned count of how many "
                  " labels there are in the original SIG RR owner name not counting the "
                  " null label for root and not counting any initial \"*\" for a wildcard. "):
              ToSubClass
        ]
    uint16 Labels;
        [Read: ToSubClass ,
              Description("The TTL of the RRset signed by this SIG "):
              ToSubClass
        ]
    uint32 OriginalTTL;
        [Read: ToSubClass ,
              Description("SIG is valid until Signature Expiration. Signature Expiration "
                  " is specified in number of seconds since the start of 1 January 1970, "
                  " GMT, ignoring leap seconds. "):
              ToSubClass
        ]
    uint32 SignatureExpiration;
        [Read: ToSubClass ,
              Description("SIG is valid after Signature Inception. Signature Inception"
                  " is specified in number of seconds since the start of 1 January 1970, "
                  " GMT, ignoring leap seconds. "):
              ToSubClass
        ]
    uint32 SignatureInception;
        [Read: ToSubClass ,
              Description("KeyTag provides an efficient away to choose a Key"
                          "to verify SIG is more than one Keys are available. RFC 2535, "
                          "Appendix C describes how to calculate a KeyTag."):
              ToSubClass
        ]
    uint16 KeyTag;
        [Read: ToSubClass , 
             Description("The signer name is the domain name of the signer "
                 " generating the SIG RR. "): ToSubClass
        ]
    string SignerName;
        [Read: ToSubClass , 
             Description("Signature is represented in base 64 as described in the "
                 "RFC 2535, Appendix A. "): ToSubClass
        ]
    string Signature;
        [Implemented, static, Description(
         "This method instantiates a 'SIG' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/target Name, class (default = "
               "IN), 'time to live' value, TypeCovered, Algorithm, Labels, "
                  "OriginalTTL, SignatureExpiration, SignatureInception, KeyTag, "
                 " SignerName and Signature. It returns a reference to the new object "
                 "as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,     
        [IN, optional] uint32 TTL, [IN] uint16 TypeCovered, [IN] uint16 Algorithm,
                          [IN] uint16 Labels, [IN] uint32 OriginalTTL, [IN] uint32 SignatureExpiration,
                          [IN] uint32 SignatureInception, [IN] uint16 KeyTag, [IN] string SignerName,
                          [IN] string Signature, [OUT] MicrosoftDNS_SIGType ref RR); 
        
        [Implemented, Description(
        "This method updates the TTL, TypeCovered, Algorithm, Labels, OriginalTTL, "
                  "SignatureExpiration, SignatureInception, KeyTag, SignerName and Signature "
        "to the values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
        [IN] uint16 TypeCovered, [IN] uint16 Algorithm,
                          [IN] uint16 Labels, [IN] uint32 OriginalTTL, [IN] uint32 SignatureExpiration,
                          [IN] uint32 SignatureInception, [IN] uint16 KeyTag, [IN] string SignerName,
                          [IN] string Signature,
        [OUT] MicrosoftDNS_SIGType ref RR); 
};


    [
     Schema ("MicrosoftDNS"): ToSubClass ,        
     Description("A subclass of MicrosoftDNS_ResourceRecord that represents a "
          "Type NXT record."): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Locale (0x409), UUID ("{81DA27AB-72D2-442C-88EB-C0537E796D60}") 
    ]
class MicrosoftDNS_NXTType : MicrosoftDNS_ResourceRecord
{
        [Read: ToSubClass , 
         Description("Next Domain Name."): ToSubClass
        ]
    string NextDomainName;
        [Read: ToSubClass ,
         Description("Types is the space separated list of the RR types"
                       "mnemonics that exist for the owner name of the NXT RR. "):
              ToSubClass
        ]
    string Types;
        [Implemented, static, Description(
         "This method instantiates a 'NXT' Type of Resource Record based "
                 "on the data in the method's input parameters: the record's DNS "
                 "Server Name, Container Name, Owner/target Name, class (default = "
               "IN), 'time to live' value, NextDomainName and Types. "
                 " It returns a reference to the new object as an output parameter."): ToSubClass
        ]
    void CreateInstanceFromPropertyData([IN] string DnsServerName,
        [IN] string ContainerName, [IN] string OwnerName, 
        [IN, optional, Valuemap {"1", "2", "3", "4"}, Values {"IN (Internet)", 
         "CS (CSNET)", "CH (CHAOS)", "HS (Hesiod)"}] uint32 RecordClass = 1,     
        [IN, optional] uint32 TTL, [IN] string NextDomainName,
                          [IN] string Types, [OUT] MicrosoftDNS_NXTType ref RR); 
        
        [Implemented, Description(
        "This method updates the TTL, NextDomainName and Types"
        "to the values specified as the input parameters of this method. If a new "
        "value for some parameter is not specified, then the current value for "
        "this parameter is not changed. The method returns a reference to the "
        "modified object as an output parameter."): ToSubClass

        ]
    void modify(
        [IN, optional] uint32 TTL, 
                          [IN] string NextDomainName,
                          [IN] string Types,
        [OUT] MicrosoftDNS_NXTType ref RR); 
};



    [Abstract, Association: ToInstance ToSubClass DisableOverride,  
         Aggregation: ToSubClass DisableOverride, 
         Description ("A generic association to establish 'part of' relationships "
          "between managed system elements. For example, the SystemComponent "
          "association defines parts of a system."): ToSubClass,
     Locale (0x409), UUID ("{8502C573-5FBB-11D2-AAC1-006008C78BC7}") ] 
class CIM_Component
{
        [Read: ToSubClass , Aggregate:  ToSubClass DisableOverride , 
         Description ("The parent element in the association"): ToSubClass ] 
    CIM_ManagedSystemElement REF GroupComponent;
        [Description ("The child element in the association"): ToSubClass , 
         Read: ToSubClass] 
    CIM_ManagedSystemElement REF PartComponent;
};

    [
      Schema ("MicrosoftDNS"): ToSubClass , 
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Description ("Every instance of the class MicrosoftDNS_Server may contain "
          "multiple instances of the class MicrosoftDNS_Domain. Every instance of "
          "the class MicrosoftDNS_Domain belongs to a single instance of the class "
          "MicrosoftDNS_Server and is defined to be weak to that server." ): 
          ToSubClass ,
       Locale (0x409), UUID ("{6C33CF92-AA43-11d2-85DD-0000F8102E5F}") 
    ]
class MicrosoftDNS_ServerDomainContainment : CIM_Component
{
        [Key, Override ("GroupComponent"): ToSubClass ,
         Read: ToSubClass,
             Min (1): ToSubClass , Max (1): ToSubClass ,
         Description ("The DNS Server." ): ToSubClass
        ]
    MicrosoftDNS_Server REF GroupComponent;
        [Key, Override ("PartComponent"): ToSubClass , 
             Weak: DisableOverride ToSubClass, Read: ToSubClass,
         Description ("A Domain, Zone, Cache or RootHints managed "
              "by the DNS server." ): ToSubClass
        ]
    MicrosoftDNS_Domain REF PartComponent;
};

    [
       Schema ("MicrosoftDNS"): ToSubClass ,
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Description ("Domains may contain other Domains. (Every instance of "
          "the MicrosoftDNS_Domain class may contain multiple other instances of "
          "MicrosoftDNS_Domain.) An instance of a MicrosoftDNS_Domain object is "
          "directly contained in (at most) one higher level MicrosoftDNS_Domain."): 
          ToSubClass,
       Locale (0x409), UUID ("{6C33CF93-AA43-11d2-85DD-0000F8102E5F}")
     ]
class MicrosoftDNS_DomainDomainContainment : CIM_Component
{
        [Key, Max(1): ToSubClass, Override ("GroupComponent"): ToSubClass ,
         Read: ToSubClass,
         Description ("A higher level Domain, Zone, Cache or RootHints." ):
                  ToSubClass
        ]
    MicrosoftDNS_Domain REF GroupComponent;
        [Key, Override ("PartComponent"): ToSubClass , 
         Read: ToSubClass,
         Description ("The Domain contained by a higher level Domain, "
                  "Zone, Cache or RootHints." ): ToSubClass
        ]
    MicrosoftDNS_Domain REF PartComponent;
};

    [
     Schema ("MicrosoftDNS"): ToSubClass ,
     Dynamic, Provider("MS_NT_DNS_PROVIDER"),
     Description ( "Every instance of the class MicrosoftDNS_Domain may "
          "contain multiple instances of the class, MicrosoftDNS_ResourceRecord. "
          "Every instance of the class MicrosoftDNS_ResourceRecord belongs to a "
          "single instance of the class MicrosoftDNS_Domain and is defined to be "
          "weak to that instance." ): ToSubClass,
       Locale (0x409), UUID ("{767E560C-AA43-11d2-85DD-0000F8102E5F }")
     ]
class MicrosoftDNS_DomainResourceRecordContainment : CIM_Component
{
        [Key, Override ("GroupComponent"): ToSubClass , 
             Min (1): ToSubClass , Max (1): ToSubClass ,
         Read: ToSubClass,
         Description ("The Zone, Cache, RootHints or Domain directly "
                  "containing the Resource Record." ): ToSubClass
        ]
    MicrosoftDNS_Domain REF GroupComponent;
        [Key, Override ("PartComponent"): ToSubClass , 
             Weak: DisableOverride ToSubClass , Read: ToSubClass,
         Description ("The Resource Record that is contained in a Domain, "
                  "Zone, Cache or RootHints." ): ToSubClass
        ]
    MicrosoftDNS_ResourceRecord REF PartComponent;
};


[
    Schema ("MicrosoftDNS"): ToSubClass,
    Dynamic,
    Provider("MS_NT_DNS_PROVIDER"),
    Description ( "A single DNS Server statistic." ): ToSubClass,
    Locale (0x409)
]
class MicrosoftDNS_Statistic
{
    [
        Key,
        Propagated( "MicrosoftDNS_Server.Name" ): ToSubClass,
        Read: ToSubClass,
        Description(
            "Indicates the IP address or hostname of the DNS Server that "
            "contains this statistic."): ToSubClass
    ]
    string DnsServerName;

    [
        Key,
        Read: ToSubclass,
        Description( "The name of the collection this statistic "
            "belongs to." ): ToSubClass
    ]
    string CollectionName;

    [
        Key,
        Read: ToSubclass,
        Description( "The numeric ID corresponding to "
            "CollectionName." ): ToSubClass
    ]
    uint32 CollectionId;

    [
        Key,
        Read: ToSubclass,
        Description( "The name of this statistic." ): ToSubClass
    ]
    string Name;

    [
        Read: ToSubclass,
        Description( "Numeric (DWORD) value of this statistic." ): ToSubClass
    ]
    uint32 Value;

    [
        Read: ToSubclass,
        Description( "String value of this statistic. This property "
            "will only be set on statistics where the value is not "
            "of DWORD type."): ToSubClass
    ]
    string StringValue;
};


/*
[
    Schema ("MicrosoftDNS"): ToSubClass,
    Dynamic,
    Provider("MS_NT_DNS_PROVIDER"),
    Description (
        "A collection of related DNS Server statistics." ): ToSubClass,
    Locale (0x409)
]
class MicrosoftDNS_StatisticCollection : CIM_LogicalElement
{
    [
        Key,
        Read: ToSubclass,
        Description( "The name of this statistic collection." ): ToSubClass
    ]
    string Name;

    [
        Read: ToSubclass,
        Description( "Numeric ID of this statistic collection" ): ToSubClass
    ]
    uint32 StatId;

    [
        Read: ToSubclass,
        Description( "Array of values associated with this statistic "
            "collection." ): ToSubClass
    ]
    MicrosoftDNS_Statistic Statistics[];
};
*/