// Copyright (c) 2005 DMTF.  All rights reserved.
   [Version ( "2.6.0" ), 
    UMLPackagePath ( "CIM::Device::StorageDevices" ), 
    Description ( 
       "A MediaAccessDevice represents the ability to access one or "
       "more media and use this media to store and retrieve data." )]
class CIM_MediaAccessDevice : CIM_LogicalDevice {

      [Description ( 
          "Capabilities of the MediaAccessDevice. For example, the "
          "Device may support \"Random Access\", removeable media "
          "and \"Automatic Cleaning\". In this case, the values 3, "
          "7 and 9 would be written to the array. \n"
          "Several of the enumerated values require some "
          "explanation: 1) Value 11, Supports Dual Sided Media, "
          "distinguishes a Device that can access both sides of "
          "dual sided Media, from a Device that reads only a single "
          "side and requires the Media to be flipped; and, 2) Value "
          "12, Predismount Eject Not Required, indicates that Media "
          "does not have to be explicitly ejected from the Device "
          "before being accessed by a PickerElement." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
          "10", "11", "12" }, 
       Values { "Unknown", "Other", "Sequential Access", 
          "Random Access", "Supports Writing", "Encryption", 
          "Compression", "Supports Removeable Media", 
          "Manual Cleaning", "Automatic Cleaning", 
          // 10               
          "SMART Notification", 
          "Supports Dual Sided Media", 
          "Predismount Eject Not Required" }, 
       ArrayType ( "Indexed" ), 
       MappingStrings { "MIF.DMTF|Storage Devices|001.9", 
          "MIF.DMTF|Storage Devices|001.11", 
          "MIF.DMTF|Storage Devices|001.12", "MIF.DMTF|Disks|003.7", 
          "MIF.DMTF|Host Disk|001.2", "MIF.DMTF|Host Disk|001.4" }, 
       ModelCorrespondence { 
          "CIM_MediaAccessDevice.CapabilityDescriptions" }]
   uint16 Capabilities[];

      [Description ( 
          "An array of free-form strings providing more detailed "
          "explanations for any of the AccessDevice features "
          "indicated in the Capabilities array. Note, each entry of "
          "this array is related to the entry in the Capabilities "
          "array that is located at the same index." ), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_MediaAccessDevice.Capabilities" }]
   string CapabilityDescriptions[];

      [Description ( 
          "ErrorMethodology is a free-form string describing the "
          "type(s) of error detection and correction supported by "
          "this Device." )]
   string ErrorMethodology;

      [Description ( 
          "A free form string indicating the algorithm or tool used "
          "by the device to support compression. If it is not "
          "possible or not desired to describe the compression "
          "scheme (perhaps because it is not known), recommend "
          "using the following words: \"Unknown\" to represent that "
          "it is not known whether the device supports compression "
          "capabilities or not, \"Compressed\" to represent that "
          "the device supports compression capabilities but either "
          "its compression scheme is not known or not disclosed, "
          "and \"Not Compressed\" to represent that the devices "
          "does not support compression capabilities." )]
   string CompressionMethod;

      [Description ( 
          "When the MediaAccessDevice supports multiple individual "
          "Media, this property defines the maximum number which "
          "can be supported or inserted." )]
   uint32 NumberOfMediaSupported;

      [Description ( 
          "Maximum size, in KBytes, of media supported by this "
          "Device. KBytes is interpreted as the number of bytes "
          "multiplied by 1000 (NOT the number of bytes multiplied "
          "by 1024)." ), 
       MappingStrings { "MIF.DMTF|Sequential Access Devices|001.2", 
          "MIF.DMTF|Host Disk|001.5" }]
   uint64 MaxMediaSize;

      [Description ( 
          "Default block size, in bytes, for this Device." ), 
       Units ( "Bytes" ), 
       PUnit ( "byte" )]
   uint64 DefaultBlockSize;

      [Description ( 
          "Maximum block size, in bytes, for media accessed by this Device."
           ), 
       Units ( "Bytes" ), 
       PUnit ( "byte" )]
   uint64 MaxBlockSize;

      [Description ( 
          "Minimum block size, in bytes, for media accessed by this Device."
           ), 
       Units ( "Bytes" ), 
       PUnit ( "byte" )]
   uint64 MinBlockSize;

      [Description ( 
          "Boolean indicating that the MediaAccessDevice needs "
          "cleaning. Whether manual or automatic cleaning is "
          "possible is indicated in the Capabilities array "
          "property." )]
   boolean NeedsCleaning;

      [Description ( 
          "True indicates that the media is locked in the Device "
          "and can not be ejected. For non-removeable Devices, this "
          "value should be true." )]
   boolean MediaIsLocked;

      [Description ( 
          "An enumeration indicating the operational security "
          "defined for the MediaAccessDevice. For example, "
          "information that the Device is \"Read Only\" (value=4) "
          "or \"Boot Bypass\" (value=6) can be described using this "
          "property." ), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7" }, 
       Values { "Other", "Unknown", "None", "Read Only", 
          "Locked Out", "Boot Bypass", "Boot Bypass and Read Only" }, 
       MappingStrings { "MIF.DMTF|Disks|003.22" }]
   uint16 Security;

      [Description ( 
          "The date and time on which the Device was last cleaned." )]
   datetime LastCleaned;

      [Description ( 
          "Time in milliseconds to move from the first location on "
          "the Media to the location that is furthest with respect "
          "to time. For a DiskDrive, this represents full seek + "
          "full rotational delay. For TapeDrives, this represents a "
          "search from the beginning of the tape to the most "
          "physically distant point. (The end of a tape may be at "
          "its most physically distant point, but this is not "
          "necessarily true.)" ), 
       Units ( "MilliSeconds" ), 
       PUnit ( "second * 10^-3" )]
   uint64 MaxAccessTime;

      [Description ( 
          "The sustained data transfer rate in KB/sec that the "
          "Device can read from and write to a Media. This is a "
          "sustained, raw data rate. Maximum rates or rates "
          "assuming compression should not be reported in this "
          "property." ), 
       Units ( "KiloBytes per Second" ), 
       PUnit ( "byte / second * 10^3" )]
   uint32 UncompressedDataRate;

      [Description ( 
          "Time in milliseconds from \'load\' to being able to read "
          "or write a Media. For example, for DiskDrives, this is "
          "the interval between a disk not spinning to the disk "
          "reporting that it is ready for read/write (ie, the disk "
          "spinning at nominal speeds). For TapeDrives, this is the "
          "time from a Media being injected to reporting that it is "
          "ready for an application. This is usually at the tape\'s "
          "BOT area." ), 
       Units ( "MilliSeconds" ), 
       PUnit ( "second * 10^-3" )]
   uint64 LoadTime;

      [Description ( 
          "Time in milliseconds from being able to read or write a "
          "Media to its \'unload\'. For example, for DiskDrives, "
          "this is the interval between a disk spinning at nominal "
          "speeds and a disk not spinning. For TapeDrives, this is "
          "the time for a Media to go from its BOT to being fully "
          "ejected and accessible to a PickerElement or human "
          "operator." ), 
       Units ( "MilliSeconds" ), 
       PUnit ( "second * 10^-3" )]
   uint64 UnloadTime;

      [Description ( 
          "For a MediaAccessDevice that supports removable Media, "
          "the number of times that Media have been mounted for "
          "data transfer or to clean the Device. For Devices "
          "accessing nonremovable Media, such as hard disks, this "
          "property is not applicable and should be set to 0." ), 
       Counter]
   uint64 MountCount;

      [Description ( 
          "For a MediaAccessDevice that supports removable Media, "
          "the most recent date and time that Media was mounted on "
          "the Device. For Devices accessing nonremovable Media, "
          "such as hard disks, this property has no meaning and is "
          "not applicable." )]
   datetime TimeOfLastMount;

      [Description ( 
          "For a MediaAccessDevice that supports removable Media, "
          "the total time (in seconds) that Media have been mounted "
          "for data transfer or to clean the Device. For Devices "
          "accessing nonremovable Media, such as hard disks, this "
          "property is not applicable and should be set to 0." )]
   uint64 TotalMountTime;

      [Description ( 
          "Defines \'Units\' relative to its use in the property, "
          "MaxUnitsBeforeCleaning. This describes the criteria used "
          "to determine when the MediaAccessDevice should be "
          "cleaned." ), 
       ModelCorrespondence { 
          "CIM_MediaAccessDevice.MaxUnitsBeforeCleaning", 
          "CIM_MediaAccessDevice.UnitsUsed" }]
   string UnitsDescription;

      [Description ( 
          "An unsigned integer indicating the maximum \'units\' "
          "that can be used, with respect to the AccessDevice, "
          "before the Device should be cleaned. The property, "
          "UnitsDescription, defines how \'units\' should be "
          "interpreted." ), 
       ModelCorrespondence { "CIM_MediaAccessDevice.UnitsDescription" }]
   uint64 MaxUnitsBeforeCleaning;

      [Description ( 
          "An unsigned integer indicating the currently used "
          "\'units\' of the AccessDevice, helpful to describe when "
          "the Device may require cleaning. The property, "
          "UnitsDescription, defines how \'units\' should be "
          "interpreted." ), 
       Gauge, ModelCorrespondence { 
          "CIM_MediaAccessDevice.UnitsDescription", 
          "CIM_MediaAccessDevice.MaxUnitsBeforeCleaning" }]
   uint64 UnitsUsed;


      [Description ( 
          "Method to lock and unlock the media in a removeable "
          "Access Device. The method takes one parameter as input - "
          "a boolean indicating whether to lock or unlock. TRUE "
          "indicates that the media should be locked in the Device, "
          "FALSE indicates that the media should be unlocked. The "
          "method returns 0 if successful, 1 if not supported, and "
          "any other value if an error occurred. The set of "
          "possible return codes should be specified in a ValueMap "
          "qualifier on the method. The strings to which the "
          "ValueMap contents are \'translated\' should be specified "
          "as a Values array qualifier on the method." )]
   uint32 LockMedia(
         [IN, Description ( 
             "If TRUE, lock the media. If FALSE release the media."
              )]
      boolean Lock);

};
