// Copyright (c) 2013 DMTF.  All rights reserved.
   [Version ( "2.41.0" ), 
    UMLPackagePath ( "CIM::Device::StorageServices" ), 
    Description ( 
       "A StoragePool is a conglomeration of storage capacity for the "
       "purpose of assignment and allocation based on service "
       "characteristics, such as location, available space or other "
       "criteria (for example, cost per megabyte or hardware "
       "ownership). A StoragePool is managed within the scope of a "
       "particular System. StoragePools may consist of component "
       "StoragePools or StorageExtents. StorageExtents that belong to "
       "the StoragePool have a Component relationship to the "
       "StoragePool. StorageExtents/StoragePools that are elements of "
       "a pool have their available space aggregated into the pool. "
       "StoragePools, StorageVolumes and LogicalDisks may be created "
       "from StoragePools. This is indicated by the "
       "AllocatedFromStoragePool association. StoragePool is scoped to "
       "a system by the HostedStoragePool association." )]
class CIM_StoragePool : CIM_ResourcePool {

      [Key, Override ( "InstanceID" ), 
       Description ( 
          "Within the scope of the instantiating Namespace, "
          "InstanceID opaquely and uniquely identifies an instance "
          "of this class. In order to ensure uniqueness within the "
          "NameSpace, the value of InstanceID SHOULD be constructed "
          "using the following \'preferred\' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon "
          "\':\', and where <OrgID> MUST include a copyrighted, "
          "trademarked or otherwise unique name that is owned by "
          "the business entity creating/defining the InstanceID, or "
          "is a registered ID that is assigned to the business "
          "entity by a recognized global authority (This is similar "
          "to the <Schema Name>_<Class Name> structure of Schema "
          "class names.) In addition, to ensure uniqueness <OrgID> "
          "MUST NOT contain a colon (\':\'). When using this "
          "algorithm, the first colon to appear in InstanceID MUST "
          "appear between <OrgID> and <LocalID>. \n"
          "<LocalID> is chosen by the business entity and SHOULD "
          "not be re-used to identify different underlying "
          "(real-world) elements. If the above \'preferred\' "
          "algorithm is not used, the defining entity MUST assure "
          "that the resultant InstanceID is not re-used across any "
          "InstanceIDs produced by this or other providers for this "
          "instance\'s NameSpace. \n"
          "For DMTF defined instances, the \'preferred\' algorithm "
          "MUST be used with the <OrgID> set to \'CIM\'." )]
   string InstanceID;

      [Required, Override ( "PoolID" ), 
       Description ( 
          "A unique name in the context of the System that "
          "identifies this pool." ), 
       MaxLen ( 256 )]
   string PoolID;

      [Override ( "Primordial" ), 
       Description ( 
          "If true, \"Primordial\" indicates that this StoragePool "
          "is the base from which storage capacity is drawn and "
          "returned in the activity of storage management. Being "
          "primordial means that this StoragePool shall not be "
          "created or deleted by consumers of this model. However, "
          "other actions, modeled or not, may affect the "
          "characteristics or size of primordial StoragePools. If "
          "false, \"Primordial\" indicated that the StoragePool, a "
          "concrete Storage Pool, is subject to storage services "
          "functions. This distinction is important because "
          "higher-level StoragePools may be assembled using the "
          "Component or AllocatedFromStoragePool associations. "
          "Although the higher-level abstractions can be created "
          "and deleted, the most basic, (i.e. primordial), "
          "hardware-based StoragePools cannot. They are physically "
          "realized as part of the System, or are actually managed "
          "by some other System and imported as if they were "
          "physically realized." )]
   boolean Primordial = false;

      [Description ( 
          "The total amount of capacity usable for the allocation "
          "of StorageVolumes, LogicalDisks, or child Storage Pools. \n"
          "For primordial Storage Pools, this capacity reflects the "
          "usable capacity of Disk Drives or LUNs, for example, to "
          "the owning storage device or application. For example, "
          "in storage array, a primordial Storage Pool\'s "
          "TotalManagedSpace does not include metadata such as the "
          "disk label area and absolute disk drive capacity lost in "
          "disk formatting. \n"
          "For concrete Storage Pools, the same applies, but the "
          "metadata not included in TotalManagedSpace is consumed "
          "in virtualization like RAID and concatenation. Concrete "
          "Storage Pool may also be simple reserve of capacity. In "
          "such a case, no capacity may be lost in formation of the "
          "Storage Pool. \n"
          "Conceptually TotalManagedSpace is the sum of all storage "
          "known via AssociatedComponentExtent associations to "
          "underlying StorageExtents. However, note some of these "
          "underlying storage may not be modeled by the "
          "instrumentation." ), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.RemainingManagedSpace" }, 
       PUnit ( "byte" )]
   uint64 TotalManagedSpace;

      [Required, Description ( 
          "The remaining usable capacity after the allocation of "
          "StorageVolumes, LogicalDisks, or child Storage Pools. "
          "This property is maintained here to provide efficient "
          "access to this information. However, note that it is "
          "possible to compute RemainingManagedSpace as "
          "(TotalManagedSpace minus the sum of SpaceConsumed from "
          "all of the AllocatedFromStoragePool references from this "
          "StoragePool). Note that SpaceConsumed remains useful to "
          "determine the amount of capacity consumed by a "
          "particular allocated element." ), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace", 
          "CIM_AllocatedFromStoragePool.SpaceConsumed" }, 
       PUnit ( "byte" )]
   uint64 RemainingManagedSpace;

      [Experimental, Description ( 
          "LowSpaceWarningThreshold simplifies the creation of a "
          "pool specific Indication based on RemainingManagedSpace "
          "<= \n"
          "(TotalManagedSpace*LowSpaceWarningThreshold)/100. One "
          "example client for an Indication based on this property "
          "is a delta copy implementation where the pool enables "
          "continuous, variable space consumption for the delta "
          "storage. Another example client for an Indication based "
          "on this property is a provisioning manager implementing "
          "a policy for adding storage to a pool when it becomes "
          "low." ), 
       Units ( "Percentage" ), 
       MinValue ( 0 ), 
       MaxValue ( 100 ), 
       ModelCorrespondence { "CIM_StoragePool.RemainingManagedSpace" }, 
       PUnit ( "percent" )]
   uint16 LowSpaceWarningThreshold;

      [Experimental, Description ( 
          "Indicates the intended usage or any restrictions that "
          "may have been imposed on the usage of this component. "
          "For example, a storage pool may be reserved for use by "
          "the block server. In that case the Usage of the storage "
          "pool is marked as \"Reserved for the ComputerSystem\". "
          "In the case of \"Other\", see OtherUsageDescription for "
          "more information." ), 
       ValueMap { "1", "2", "3", "4", "5", "6", "7", "8", "..", 
          "32768..65535" }, 
       Values { "Other", "Unrestricted", 
          "Reserved for ComputerSystem (the block server)", 
          "Reserved as a Delta Replica Container", 
          "Reserved for Migration Services", 
          "Reserved for Local Replication Services", 
          "Reserved for Remote Replication Services", 
          "Reserved for Sparing", "DMTF Reserved", "Vendor Reserved" }, 
       ModelCorrespondence { "CIM_StoragePool.OtherUsageDescription" }]
   uint16 Usage;

      [Experimental, Description ( 
          "Populated when \"Usage\" has the value of \"Other\"." ), 
       ModelCorrespondence { "CIM_StoragePool.Usage" }]
   string OtherUsageDescription;

      [Experimental, Description ( 
          "Indicates which values from the \"Usage\" valuemap can "
          "be manipulated by a client using the method "
          "\"StorageConfigurationService.RequestUsageChange\"." ), 
       ModelCorrespondence { "CIM_StoragePool.Usage" }]
   uint16 ClientSettableUsage[];

      [Experimental, Description ( 
          "The total capacity of extents in migrating out from this "
          "storage pool" ), 
       Units ( "Bytes" )]
   uint64 CapacityInMigratingSource;

      [Experimental, Description ( 
          "The total capacity of extents in migrating into this storage pool"
           ), 
       Units ( "Bytes" )]
   uint64 CapacityInMigratingTarget;

      [Experimental, Description ( 
          "The capacity of the storage allocated to the pool when "
          "SpaceLimitDetermination has the value 3 (Quota) or 4 "
          "(Limitless) or is set to the value of TotalManagedSpace "
          "if SpaceLimitDetermination has the value 2 (Allocated)." ), 
       Units ( "Bytes" ), 
       PUnit ( "byte" )]
   uint64 SpaceLimit;

      [Experimental, Description ( 
          "This property is the Subsystem ID if the array or "
          "virtualizer supports Subsystem IDs. If they are "
          "supported they would be required on volume creation." ), 
       ValueMap { "2", "3", "4" }, 
       Values { "Allocated", "Quote", "Limitless" }]
   uint16 SpaceLimitDetermination;

      [Experimental, Description ( 
          "The size of metadata consumed by this storage pool. Only "
          "defined if the pool is thin provisioned." ), 
       Units ( "Bytes" ), 
       PUnit ( "byte" )]
   uint64 ThinProvisionMetaDataSpace;

      [Experimental, Description ( 
          "If true, it indicates elements allocated from the "
          "storage pool are sharing space from the storage pool. "
          "For example, multiple snapshots \"allocated\" from a "
          "storage pool, point to the same blocks of the storage "
          "pool. As another example, elements utilizing "
          "de-duplication technology refer to a shared copy of the "
          "data stored in the storage pool." )]
   boolean ElementsShareSpace = false;

      [Experimental, Description ( 
          "The amount of capacity used by the storage pool to store "
          "information about the configuration of the storage pool. "
          "The space is not included in the TotalManagedSpace of "
          "the storage pool." ), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace" }, 
       PUnit ( "byte" )]
   uint64 ReservedSpace;


      [Description ( 
          "For pools that that support a range of sizes for volume "
          "or pool creation, this method can be used to retrieve "
          "the supported range. Note that different pool "
          "implementations may support either or both the "
          "GetSupportedSizes and GetSupportedSizeRanges methods at "
          "different times, depending on Pool configuration. Also "
          "note that the advertised sizes may change after the call "
          "due to requests from other clients. If the pool "
          "currently only supports discrete sizes, then the return "
          "value will be set to 1." ), 
       ValueMap { "0", "1", "2", "3" }, 
       Values { "Method completed OK", "Method not supported", 
          "Use GetSupportedSizeRange instead", "Invalid Element Type" }]
   uint32 GetSupportedSizes(
         [Experimental, IN, Description ( 
             "The type of element for which supported sizes are "
             "reported. The Thin Provision values are only "
             "supported when the Thin Provisioning Profile is "
             "supported; the resulting StorageVolume/LogicalDisk "
             "shall have ThinlyProvisioned set to true." ), 
          ValueMap { "2", "3", "4", "5", "6" }, 
          Values { "Storage Pool", "Storage Volume", 
             "Logical Disk", "Thin Provisioned Volume", 
             "Thin Provisioned Logical Disk" }]
      uint16 ElementType, 
         [IN, Description ( 
             "The StorageSetting for which supported sizes "
             "should be reported for." )]
      CIM_StorageSetting REF Goal, 
         [IN, OUT, Description ( 
             "List of supported sizes for a Volume/Pool creation "
             "or modification." ), 
          Units ( "Bytes" ), 
          PUnit ( "byte" )]
      uint64 Sizes[]);

      [Description ( 
          "For pools that that support a range of sizes for volume "
          "or pool creation, this method can be used to retrieve "
          "the supported range. Note that different pool "
          "implementations may support either or both the "
          "GetSupportedSizes and GetSupportedSizeRanges methods at "
          "different times, depending on Pool configuration. Also "
          "note that the advertised sizes may change after the call "
          "due to requests from other clients. If the pool "
          "currently only supports discrete sizes, then the return "
          "value will be set to 1." ), 
       ValueMap { "0", "1", "2", "3" }, 
       Values { "Method completed OK", "Method not supported", 
          "Use GetSupportedSizes instead", "Invalid Element Type" }]
   uint32 GetSupportedSizeRange(
         [Experimental, IN, Description ( 
             "The type of element for which supported size "
             "ranges are reported. The Thin Provision values are "
             "only supported when the Thin Provisioning Profile "
             "is supported; the resulting "
             "StorageVolume/LogicalDisk shall have "
             "ThinlyProvisioned set to true." ), 
          ValueMap { "2", "3", "4", "5", "6" }, 
          Values { "Storage Pool", "Storage Volume", 
             "Logical Disk", "Thin Provisioned Volume", 
             "Thin Provisioned Logical Disk" }]
      uint16 ElementType, 
         [IN, Description ( 
             "The StorageSetting for which supported size ranges "
             "should be reported for." )]
      CIM_StorageSetting REF Goal, 
         [IN, OUT, Description ( 
             "The minimum size for a volume/pool in bytes." ), 
          Units ( "Bytes" ), 
          PUnit ( "byte" )]
      uint64 MinimumVolumeSize, 
         [IN, OUT, Description ( 
             "The maximum size for a volume/pool in bytes." ), 
          Units ( "Bytes" ), 
          PUnit ( "byte" )]
      uint64 MaximumVolumeSize, 
         [IN, OUT, Description ( 
             "A volume/pool size must be a multiple of this "
             "value which is specified in bytes." ), 
          Units ( "Bytes" ), 
          PUnit ( "byte" )]
      uint64 VolumeSizeDivisor);

      [Description ( 
          "This method can be used to retrieve a list of available "
          "Extents that may be used in the creation or modification "
          "of a StoragePool, StorageVolume, or LogicalDisk. The "
          "GetAvailableExtents method MUST return the Extents from "
          "the set of Component Extents of the Pool on which the "
          "method is being invoked. The returned Extents are "
          "available at the time the method returns. There is no "
          "guarantee that the same Extents will be available later. "
          "This method MUST return the Extents that are not being "
          "used as supporting capacity for any other Pools, "
          "Volumes, or LogicalDisks that have been allocated from "
          "this Pool. The Extent returned MUST be a component "
          "Extent of the Pool or subdivisions of a component "
          "Extent, the subdivisions themselves represented as "
          "Extents." ), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", 
          "4098..32767", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", 
          "Unknown", "Timeout", "Failed", "Invalid Parameter", 
          "In Use", "DMTF Reserved", "Method Reserved", 
          "Vendor Specific" }]
   uint32 GetAvailableExtents(
         [IN, Description ( 
             "The StorageSetting (Goal) for which supported "
             "extents should be retrieved as available. \n"
             "If a NULL is passed for the Goal, the method will "
             "return all available extents, regardless of the "
             "goal. There exists a possibility of error in "
             "creating a Pool, Volume, or LogicalDisk retrieved "
             "in this manner." )]
      CIM_StorageSetting REF Goal, 
         [OUT, Description ( 
             "List of references to available StorageExtents, or "
             "subclass instances." )]
      CIM_StorageExtent REF AvailableExtents[]);

};