// Copyright (c) 2005 DMTF.  All rights reserved.
// <change cr="DMTFCR01378.002" type ="change">Update of description to
// support deprecation of CIM_Profile and
// CIM_Configuration.</change>
// <change cr="SysDevCR00728.000" type ="change">Update of
// descriptions based on Tech Edit review.</
// <change cr="ArchCR00066.004" type="add">Add UmlPackagePath
// qualifier values to CIM Schema.</change>
// ==================================================================
//  CIM_Setting
// ==================================================================
   [Abstract, Version ( "2.8.1000" ), 
    UMLPackagePath ( "CIM::Core::Settings" ), 
    Description ( 
       "The Setting class represents configuration-related and "
       "operational parameters for one or more ManagedSystemElements. "
       "An Element can have multiple Setting objects associated with "
       "it. The current operational values for the parameters of an "
       "Element are reflected by properties in the Element itself or "
       "by properties in its associations. These properties do not "
       "have to be the same values present in the Setting object. For "
       "example, a modem might have a Setting baud rate of 56Kb/sec "
       "but be operating at 19.2Kb/sec. \n"
       "Note: The CIM_SettingData class is very similar to "
       "CIM_Setting, yet both classes are present in the model because "
       "many implementations have successfully used CIM_Setting. "
       "However, issues have arisen that could not be resolved without "
       "defining a new class. Therefore, until a new major release "
       "occurs, both classes will exist in the model. Refer to the "
       "Core White Paper for additional information. Setting instances "
       "can be aggregated together into higher-level Setting objects "
       "using ConcreteComponent associations." )]
class CIM_Setting : CIM_ManagedElement {

      [Description ( 
          "The identifier by which the Setting object is known." ), 
       MaxLen ( 256 )]
   string SettingID;


      [Description ( 
          "The VerifyOKToApplyToMSE method is used to verify that "
          "this Setting can be applied to the referenced "
          "ManagedSystemElement at the given time or time interval. "
          "This method takes three input parameters: MSE (the "
          "Managed SystemElement that is being verified), "
          "TimeToApply (which, being a datetime, can be either a "
          "specific time or a time interval), and MustBeCompletedBy "
          "(which indicates the required completion time for the "
          "method). The return value should be 0 if it is okay to "
          "apply the Setting, 1 if the method is not supported, 2 "
          "if the Setting cannot be applied within the specified "
          "times, and any other number if an error occurred. In a "
          "subclass, the set of possible return codes could be "
          "specified using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier." )]
   uint32 VerifyOKToApplyToMSE(
         [IN, Description ( 
             "The ManagedSystemElement that is being verified." )]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy);

      [Description ( 
          "The ApplyToMSE method performs the actual application of "
          "the Setting to the referenced ManagedSystemElement. It "
          "takes three input parameters: MSE (the "
          "ManagedSystemElement to which the Setting is being "
          "applied), TimeToApply (which, being a datetime, can be "
          "either a specific time or a time interval), and "
          "MustBeCompletedBy (which indicates the required "
          "completion time for the method). Note that the semantics "
          "of this method are that individual Settings are either "
          "wholly applied or not applied at all to their target "
          "ManagedSystemElement. The return value should be 0 if "
          "the Setting is successfully applied to the referenced "
          "ManagedSystemElement, 1 if the method is not supported, "
          "2 if the Setting was not applied within the specified "
          "times, and any other number if an error occurred. In a "
          "subclass, the set of possible return codes could be "
          "specified, using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier. \n"
          "Note: If an error occurs when applying the Setting to a "
          "ManagedSystemElement, the Element must be configured as "
          "it was when the \"Apply\" attempt began. That is, the "
          "Element should not be left in an indeterminate state." )]
   uint32 ApplyToMSE(
         [IN, Description ( 
             "The ManagedSystemElement to which the Setting is being applied."
              )]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy);

      [Description ( 
          "The VerifyOKToApplyToCollection method is used to verify "
          "that this Setting can be applied to the referenced "
          "Collection of ManagedSystemElements, at the given time "
          "or time interval, without causing adverse effects to "
          "either the Collection itself or its surrounding "
          "environment. The net effect is to execute the "
          "VerifyOKToApply method against each of the Elements that "
          "are aggregated by the Collection. This method takes "
          "three input parameters: Collection (the Collection of "
          "ManagedSystemElements that is being verified), "
          "TimeToApply (which, being a datetime, can be either a "
          "specific time or a time interval), and MustBeCompletedBy "
          "(which indicates the required completion time for the "
          "method). The return value should be 0 if it is okay to "
          "apply the Setting, 1 if the method is not supported, 2 "
          "if the Setting cannot be applied within the specified "
          "times, and any other number if an error occurred. One "
          "output parameter, CanNotApply, is defined, which is a "
          "string array that lists the keys of the "
          "ManagedSystemElements to which the Setting cannot be "
          "applied. This parameter enables those Elements to be "
          "revisited and either fixed or have other corrective "
          "action taken on them. \n"
          "In a subclass, the set of possible return codes could be "
          "specified, using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier." )]
   uint32 VerifyOKToApplyToCollection(
         [IN, Description ( 
             "The Collection of ManagedSystemElements that is being verified."
              )]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy, 
         [IN ( false ), OUT, Description ( 
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting cannot "
             "be applied." )]
      string CanNotApply[]);

      [Description ( 
          "The ApplyToCollection method performs the application of "
          "the Setting to the referenced Collection of "
          "ManagedSystemElements. The net effect is to execute the "
          "ApplyToMSE method against each of the Elements that are "
          "aggregated by the Collection. If the input value "
          "ContinueOnError is false, this method applies the "
          "Setting to all Elements in the Collection until it "
          "encounters an error. In the case of an error, the method "
          "stops execution, logs the key of the Element that caused "
          "the error in the CanNotApply array, and issues a return "
          "code of 2. If the input value ContinueOnError is true, "
          "then this method applies the Setting to all of the "
          "ManagedSystemElements in the Collection, and reports the "
          "failed Elements in the array, CanNotApply. For the "
          "latter, processing will continue until the method is "
          "applied to all Elements in the Collection, regardless of "
          "any errors encountered. The key of each "
          "ManagedSystemElement to which the Setting could not be "
          "applied is logged into the CanNotApply array. This "
          "method takes four input parameters: Collection (the "
          "Collection of Elements to which the Setting is being "
          "applied), TimeToApply (which, being a datetime, can be "
          "either a specific time or a time interval), "
          "ContinueOnError (true indicates to continue processing "
          "when an error is encountered), and MustBeCompletedBy "
          "(which indicates the required completion time for the "
          "method). The return value should be 0 if the Setting is "
          "successfully applied to the referenced Collection, 1 if "
          "the method is not supported, 2 if the Setting was not "
          "applied within the specified times, 3 if the Setting "
          "cannot be applied using the input value for "
          "ContinueOnError, and any other number if an error "
          "occurred. One output parameter, CanNotApplystring, is "
          "defined, which is an array that lists the keys of the "
          "ManagedSystemElements to which the Setting could not be "
          "applied. This output parameter has meaning only when the "
          "ContinueOnError parameter is true. \n"
          "In a subclass, the set of possible return codes could be "
          "specified using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier. \n"
          "Note: If an error occurs when applying the Setting to a "
          "ManagedSystemElement in the Collection, the Element must "
          "be configured as it was when the \"Apply\" attempt "
          "began. That is, the Element should not be left in an "
          "indeterminate state." )]
   uint32 ApplyToCollection(
         [IN, Description ( 
             "The Collection of ManagedSystemElements to be applied."
              )]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "True means to continue processing when an error is encountered."
              )]
      boolean ContinueOnError, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy, 
         [IN ( false ), OUT, Description ( 
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting could "
             "not be applied." )]
      string CanNotApply[]);

      [Description ( 
          "The VerifyOKToApplyIncrementalChangeToMSE method is used "
          "to verify that a subset of the properties in this "
          "Setting can be applied to the referenced "
          "ManagedSystemElement at the given time or time interval. "
          "This method takes four input parameters: MSE (the "
          "ManagedSystemElement that is being verified), "
          "TimeToApply (which, being a datetime, can be either a "
          "specific time or a time interval), MustBeCompletedBy "
          "(which indicates the required completion time for the "
          "method), and a PropertiesToApply array (which contains a "
          "list of the property names whose values will be "
          "verified). If the array is null or empty or contains the "
          "string \"ALL\" as a property name, then all Settings "
          "properties will be verified. If it is set to \"NONE\", "
          "then no Settings properties will be verified. The return "
          "value should be 0 if it is okay to apply the Setting, 1 "
          "if the method is not supported, 2 if the Setting cannot "
          "be applied within the specified times, and any other "
          "number if an error occurred. In a subclass, the set of "
          "possible return codes could be specified using a "
          "ValueMap qualifier on the method. The strings to which "
          "the ValueMap contents are \"translated\" can also be "
          "specified in the subclass as a Values array qualifier." )]
   uint32 VerifyOKToApplyIncrementalChangeToMSE(
         [IN, Description ( 
             "The ManagedSystemElement for which the Setting is "
             "being verified." )]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy, 
         [IN, Description ( 
             "A list of the property names whose values will be verified."
              )]
      string PropertiesToApply[]);

      [Description ( 
          "The ApplyIncrementalChangeToMSE method performs the "
          "actual application of a subset of the properties in the "
          "Setting to the referenced ManagedSystemElement. It takes "
          "four input parameters: MSE (the ManagedSystem Element to "
          "which the Setting is being applied), TimeToApply (which, "
          "being a datetime, can be either a specific time or a "
          "time interval), MustBeCompletedBy (which indicates the "
          "required completion time for the method), and a "
          "PropertiesToApply array (which contains a list of the "
          "property names whose values will be applied). If a "
          "property is not in this list, it will be ignored by the "
          "Apply. If the array is null, empty, or contains the "
          "string \"ALL\" as a property name, then all Settings "
          "properties will be applied. If it is set to \"NONE\", "
          "then no Settings properties will be applied. \n"
          "Note that the semantics of this method are that "
          "individual Settings are either wholly applied or not "
          "applied at all to their target ManagedSystemElement. The "
          "return value should be 0 if the Setting is successfully "
          "applied to the referenced ManagedSystemElement, 1 if the "
          "method is not supported, 2 if the Setting was not "
          "applied within the specified times, and any other number "
          "if an error occurred. In a subclass, the set of possible "
          "return codes could be specified using a ValueMap "
          "qualifier on the method. The strings to which the "
          "ValueMap contents are \"translated\" can also be "
          "specified in the subclass as a Values array qualifier. \n"
          "Note: If an error occurs when applying the Setting to a "
          "ManagedSystemElement, the Element must be configured as "
          "it was when the \"Apply\" attempt began. That is, the "
          "Element should not be left in an indeterminate state." )]
   uint32 ApplyIncrementalChangeToMSE(
         [IN, Description ( 
             "The ManagedSystemElement to which the Setting is being applied."
              )]
      CIM_ManagedSystemElement REF MSE, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy, 
         [IN, Description ( 
             "A list of the property names whose values will be applied."
              )]
      string PropertiesToApply[]);

      [Description ( 
          "The VerifyOKToApplyIncrementalChangeToCollection method "
          "is used to verify that a subset of the properties in "
          "this Setting can be applied to the referenced Collection "
          "of ManagedSystemElements at the given time or time "
          "interval, without causing adverse effects to either the "
          "Collection itself or its surrounding environment. The "
          "net effect is to execute the "
          "VerifyOKToApplyIncrementalChangeToMSE method against "
          "each of the Elements that are aggregated by the "
          "Collection. This method takes four input parameters: "
          "Collection (the Collection of ManagedSystemElements that "
          "is being verified), TimeToApply (which, being a "
          "datetime, can be either a specific time or a time "
          "interval), MustBeCompletedBy (which indicates the "
          "required completion time for the method), and a "
          "PropertiesToApply array (which contains a list of the "
          "property names whose values will be verified). If the "
          "array is null or empty or contains the string \"all\" as "
          "a property name, all Settings properties will be "
          "verified. If it is set to \"none\" then no Settings "
          "properties will be verified. The return value should be "
          "0 if it is okay to apply the Setting, 1 if the method is "
          "not supported, 2 if the Setting cannot be applied within "
          "the specified times, and any other number if an error "
          "occurred. One output parameter, CanNotApply, is defined, "
          "which is a string array that lists the keys of the "
          "ManagedSystemElements to which the Setting cannot be "
          "applied. This parameter enables those Elements to be "
          "revisited and either fixed or have other corrective "
          "action taken on them. \n"
          "In a subclass, the set of possible return codes could be "
          "specified using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier." )]
   uint32 VerifyOKToApplyIncrementalChangeToCollection(
         [IN, Description ( 
             "The Collection of ManagedSystemElements for which "
             "the setting is being verified." )]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description ( 
             "TimeToApply can be either a specific time or a time interval."
              )]
      datetime TimeToApply, 
         [IN, Description ( 
             "The required completion time for the method." )]
      datetime MustBeCompletedBy, 
         [IN, Description ( 
             "A list of the property names whose values will be verified."
              )]
      string PropertiesToApply[], 
         [IN ( false ), OUT, Description ( 
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting cannot "
             "be applied." )]
      string CanNotApply[]);

      [Description ( 
          "The ApplyIncrementalChangeToCollection method performs "
          "the application of a subset of the properties in this "
          "Setting to the referenced Collection of "
          "ManagedSystemElements. The net effect is to execute the "
          "ApplyIncrementalChangeToMSE method against each of the "
          "Elements that are aggregated by the Collection. If the "
          "input value ContinueOnError is false, this method "
          "applies the Setting to all Elements in the Collection "
          "until it encounters an error, in which case it stops "
          "execution, logs the key of the Element that caused the "
          "error in the CanNotApply array, and issues a return code "
          "of 2. If the input value ContinueOnError is true, then "
          "this method applies the Setting to all of the "
          "ManagedSystemElements in the Collection, and reports the "
          "failed Elements in the array, CanNotApply. For the "
          "latter, processing will continue until the method is "
          "applied to all Elements in the Collection, regardless of "
          "any errors encountered. The key of each "
          "ManagedSystemElement to which the Setting could not be "
          "applied is logged into the CanNotApply array. This "
          "method takes four input parameters: Collection (the "
          "Collection of Elements to which the Setting is being "
          "applied), TimeToApply (which, being a datetime, can be "
          "either a specific time or a time interval), "
          "ContinueOnError (true indicates to continue processing "
          "when an error is encountered), MustBeCompletedBy (which "
          "indicates the required completion time for the method), "
          "and a PropertiesToApply array (which contains a list of "
          "the property names whose values will be applied). If a "
          "property is not in this list, it will be ignored by the "
          "Apply. If the array is null or empty or contains the "
          "string \"ALL\" as a property name, then all Settings "
          "properties will be applied. If it is set to \"NONE\", "
          "then no Settings properties will be applied. \n"
          "The return value should be 0 if the Setting is "
          "successfully applied to the referenced Collection, 1 if "
          "the method is not supported, 2 if the Setting was not "
          "applied within the specified time, 3 if the Setting "
          "cannot be applied using the input value for "
          "ContinueOnError, and any other number if an error "
          "occurred. One output parameter, CanNotApplystring, is "
          "defined, which is an array that lists the keys of the "
          "ManagedSystemElements to which the Setting could not be "
          "applied. This output parameter has meaning only when the "
          "ContinueOnError parameter is true. \n"
          "In a subclass, the set of possible return codes could be "
          "specified using a ValueMap qualifier on the method. The "
          "strings to which the ValueMap contents are \"translated\" "
          "can also be specified in the subclass as a Values array "
          "qualifier. \n"
          "Note: If an error occurs when applying the Setting to a "
          "ManagedSystemElement in the Collection, the Element must "
          "be configured as it was when the \"Apply\" attempt "
          "began. That is, the Element should not be left in an "
          "indeterminate state." )]
   uint32 ApplyIncrementalChangeToCollection(
         [IN, Description ( 
             "The Collection of Elements to which the Setting is "
             "being applied." )]
      CIM_CollectionOfMSEs REF Collection, 
         [IN, Description ( "A specific time or a time interval." )]
      datetime TimeToApply, 
         [IN, Description ( 
             "True indicates to continue processing when an "
             "error is encountered." )]
      boolean ContinueOnError, 
         [IN, Description ( 
             "This parameter indicates the required completion "
             "time for the method." )]
      datetime MustBeCompletedBy, 
         [IN, Description ( 
             "A list of the property names whose values will be verified."
              )]
      string PropertiesToApply[], 
         [IN ( false ), OUT, Description ( 
             "A string array that lists the keys of the "
             "ManagedSystemElements to which the Setting cannot "
             "be applied." )]
      string CanNotApply[]);

};
