// ===================================================================
// Title:  System Processing
// $State: Exp $
// $Date: 2004/08/15 05:55:42 $
// $Source: /cvsroot/wbemservices/open/mof/dmtf/2.9/System_Processing.mof,v $
// $Revision: 1.1 $
// ===================================================================
//#pragma inLine ("Includes/copyright.inc")
// Copyright 1998-2004 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.
// DMTF is a not-for-profit association of industry members dedicated
// to promoting enterprise and systems management and interoperability.
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members,
// provided that correct attribution is given.
// As DMTF specifications may be revised from time to time,
// the particular version and release date should always be noted.
// 
// Implementation of certain elements of this standard or proposed
// standard may be subject to third party patent rights, including
// provisional patent rights (herein "patent rights"). DMTF makes
// no representations to users of the standard as to the existence
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or
// claimants, nor for any incomplete or inaccurate identification or
// disclosure of such rights, owners or claimants. DMTF shall have no
// liability to any party, in any manner or circumstance, under any
// legal theory whatsoever, for failure to recognize, disclose, or
// identify any such third party patent rights, or for such party's
// reliance on the standard or incorporation thereof in its product,
// protocols or testing procedures. DMTF shall have no liability to
// any party implementing such standard, whether such implementation
// is foreseeable or not, nor to any patent owner or claimant, and shall
// have no liability or responsibility for costs or losses incurred if
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the
// standard from any and all claims of infringement by a patent owner
// for such implementations.
// 
// For information about patents held by third-parties which have
// notified the DMTF that, in their opinion, such patent may relate to
// or impact implementations of DMTF standards, visit
// http://www.dmtf.org/about/policies/disclosures.php.
//#pragma inLine
// ===================================================================
// Description: The System Model defines system related management
//              concepts. This file defines the specific concepts to
//              manage processes, threads, and jobs.
// 
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined
//              by other working groups, are omitted.
// ==================================================================
// Change Log for v2.9 Preliminary Company Review
// CR1447 - Revisit CIM_MethodResult as result of changes in CR1361
// 
// Change Log for v2.9 Preliminary
//  CR1282 - Change the description of Job.PercentComplete and
//           JobProcessingStatistics.PercentComplete
//  CR1300 - Addition of Batch Job classes for GGF.
//  CR1319 - Job Control enhancements
// 
// Change Log for v2.8 Preliminary
//  CR1204 - Removal of Experimental Qualifier for System.
// 
// Change Log for v2.8 Preliminary
//  CR933  - ExecutionState additions
//  CR989  - Remove the Abstract qualifier from ScheduledJob,
//           clarify the class and several property Descriptions,
//           and fix the class and a property name
//  CR1016 - Job Updates
//  CR1048 - Add JobQueue & QueueStatisticalData
//  CR1081 - Move CIM_Job & Concrete to Core
//  CR1128  - Addition of HostedDependency
//  CR1135  - Job Recovery Properties and the RecoveryJob association
//  CR1137 - Change NumberOnQueue property (to two new properties)
//           in QueueStatisticalData and add MaxJobCPUTime to
//           JobQueue
// 
// Change Log for v2.7 Final
// CR988 - Update description and change subclassing of JobDestination
// CR994 - Update the description of InstanceID
// CR989 - Updates to the description and name of ScheduledJob
// CR969 - Remove the experimental qualifier
//       - Remove JobScheduleSettingData so it can remain experimental
//         in 2.8.
// 
// Change Log for v2.7
// CR757 - Change the subclassing of Process, Thread and Job from
//         LogicalElement to EnabledLogicalElement
// CR767 - Add the Compostion qualifer to OSProcess and ProcessThread
// CR768 - Add ScheduledJob
//       - Update class description and all property descriptions of
//         Job, and Add a new property ScheduledStartTime to Job
//       - Add OwningJobElement
//       - Add AffectedJobElement
//       - Add ConcreteJob
//       - Add ProcessOfJob
// CR875 - Clarify description of Process .KernelModeTime and
//         .UserModeTime
// ==================================================================

#pragma locale ("en_US")


// ===================================================================
// Process
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "Each instance of the CIM_Process class represents a single "
       "instance of a running program. A user of the OperatingSystem "
       "will typically see a Process as an application or task. Within "
       "an OperatingSystem, a Process is defined by a workspace of "
       "memory resources and environmental settings that are allocated "
       "to it. On a multitasking System, this workspace prevents "
       "intrusion of resources by other Processes. Additionally, a "
       "Process can execute as multiple Threads, all which run within "
       "the same workspace.")]
class CIM_Process : CIM_EnabledLogicalElement {

      [Key, Propagated ( "CIM_OperatingSystem.CSCreationClassName" ), 
       Description (
          "The scoping ComputerSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string CSCreationClassName;

      [Key, Propagated ( "CIM_OperatingSystem.CSName" ), Description (
          "The scoping ComputerSystem's Name."), 
       MaxLen ( 256 )]
   string CSName;

      [Key, Propagated ( "CIM_OperatingSystem.CreationClassName" ), 
       Description (
          "The scoping OperatingSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string OSCreationClassName;

      [Key, Propagated ( "CIM_OperatingSystem.Name" ), Description (
          "The scoping OperatingSystem's Name."), 
       MaxLen ( 256 )]
   string OSName;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Description (
          "A string used to identify the Process. A Process ID is a "
          "kind of Process Handle."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIF.DMTF|Process Information|001.1" }]
   string Handle;

      [Override ( "Name" ), Description (
          "The name of the process."), 
       MappingStrings { "MIF.DMTF|Process Information|001.6" }]
   string Name;

      [Description (
          "Priority indicates the urgency or importance of execution "
          "of a Process. If a priority is not defined for a Process, a "
          "value of 0 should be used."), 
       MappingStrings { "MIF.DMTF|Process Information|001.10" }]
   uint32 Priority;

      [Description (
          "Indicates the current operating condition of the Process. "
          "Values include ready (2), running (3), and blocked (4), "
          "among others. The majority of the enumerated values are "
          "obvious. However, a few require additional explanation: \n"
          "7 (Terminated) describes that a process has naturally "
          "completed \n"
          "8 (Stopped) describes that a process has been prematurely "
          "'stopped' by a user or other request \n"
          "10 (Ready but Relinquished Processor) describes that a "
          "process is in the Ready state, but has voluntarily "
          "relinquished execution time to other processes. For "
          "example, this state may indicate a problem when the "
          "relinquishing process is not handling items on its queues. "
          "If these semantics cannot be detected, the process should "
          "report its state as 2 (\"Ready\"). \n"
          "11 (Hung) indicates that a process is not responding and "
          "should therefore not be given further execution time."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "Unknown", "Other", "Ready", "Running", "Blocked",
          "Suspended Blocked", "Suspended Ready", "Terminated",
          "Stopped", "Growing", "Ready But Relinquished Processor",
          "Hung" }, 
       MappingStrings { "MIF.DMTF|Process Information|001.9",
          "MIF.UNIX|Process Information|13.9" }]
   uint16 ExecutionState;

      [Description (
          "A string describing the state - used when the instance's "
          "ExecutionState property is set to 1 (\"Other\"). Other "
          "ExecutionDescription should be set to NULL when the "
          "Execution State property is any value other than 1.")]
   string OtherExecutionDescription;

      [Description (
          "Time that the Process began executing.")]
   datetime CreationDate;

      [Description (
          "Time that the Process was stopped or terminated.")]
   datetime TerminationDate;

      [Description (
          "Time in kernel mode, in milliseconds. If this information "
          "is not available, or if the operating system does not "
          "distinguish between time in kernel and in user mode, a "
          "value of 0 should be used."), 
       Units ( "MilliSeconds" ), 
       MappingStrings { "MIF.DMTF|Process Information|001.13" }]
   uint64 KernelModeTime;

      [Description (
          "Time in user mode, in milliseconds. If this information is "
          "not available, a value of 0 should be used. If the "
          "operating system does not distinguish between time in "
          "kernel mode and user mode, the time should be returned in "
          "this property."), 
       Units ( "MilliSeconds" ), 
       MappingStrings { "MIF.DMTF|Process Information|001.14" }]
   uint64 UserModeTime;

      [Description (
          "The amount of memory in bytes that a Process needs to "
          "execute efficiently, for an OperatingSystem that uses "
          "page-based memory management. If an insufficient amount of "
          "memory is available (< working set size), thrashing will "
          "occur. If this information is not known, NULL or 0 should "
          "be entered. If this data is provided, it could be monitored "
          "to understand a Process' changing memory requirements as "
          "execution proceeds."), 
       Units ( "Bytes" ), Gauge]
   uint64 WorkingSetSize;
};


// ===================================================================
// OSProcess
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "A link between the OperatingSystem and Process(es) running in "
       "the context of this OperatingSystem.")]
class CIM_OSProcess : CIM_Component {

      [Aggregate, Override ( "GroupComponent" ), Min ( 1 ), Max ( 1 ), 
       Description (
          "The OperatingSystem.")]
   CIM_OperatingSystem REF GroupComponent;

      [Override ( "PartComponent" ), Weak, Description (
          "The Process running in the context of the OperatingSystem.")]
   CIM_Process REF PartComponent;
};


// ===================================================================
// ProcessExecutable
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "A link between a Process and a DataFile indicating that the "
       "File participates in the execution of the Process.")]
class CIM_ProcessExecutable : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The DataFile participating in the execution of the Process.")]
   CIM_DataFile REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Process.")]
   CIM_Process REF Dependent;
};


// ==================================================================
// ServiceProcess
// ==================================================================
   [Association, Version ( "2.6.0" ), Description (
       "CIM_ServiceProcess is an association used to establish "
       "relationships between Services and Processes. It is used to "
       "indicate if a Service is running in a particular Process. It "
       "is also used to indicate, via the ExecutionType property, if "
       "the Service started and is wholly responsible for the Process, "
       "or if the Service is running in an existing Process, perhaps "
       "with other unrelated Services, which is owned or started by a "
       "different entity. This association relates a Service with an "
       "externally visible system signature.")]
class CIM_ServiceProcess {

      [Key, Description (
          "The Service whose Process is described by this association.")]
   CIM_Service REF Service;

      [Key, Description (
          "The Process which represents or hosts the executing "
          "Service.")]
   CIM_Process REF Process;

      [Description (
          "Enumeration indicating how the Service runs in the context "
          "of, or owns the Process. \"Unknown\" indicates that the "
          "ExecutionType is not known. \"Other\" indicates that the "
          "ExecutionType does not match any of the values in the "
          "ExecutionType enumeration. \"Executes in Existing Process\" "
          "indicates that the Service is hosted in a Process that "
          "already exists in the system. The lifecycle of the Service "
          "is separate from that of the Process. \"Exeutes as "
          "Independent Process\" indicates that the Service is "
          "responsible for the lifecycle of the Process. When the "
          "Service is started, the Process is created. For example, "
          "ServletEngines can run \"InProcess\" within the existing "
          "Apache processes or \"OutOfProcess\" in its own servlet "
          "engine process. In this case the Apache process would "
          "communicate with the servlet engine process based on the "
          "content of the request. The association may be many to "
          "many."), 
       ValueMap { "0", "1", "2", "3" }, 
       Values { "Unknown", "Other", "Executes in Existing Process",
          "Executes as Independent Process" }]
   uint16 ExecutionType;
};

// ===================================================================
// Thread
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "Threads represent the ability to execute units of a Process or "
       "task in parallel. A Process can have many Threads, each of "
       "which is weak to the Process.")]
class CIM_Thread : CIM_EnabledLogicalElement {

      [Key, Propagated ( "CIM_Process.CSCreationClassName" ), 
       Description (
          "The scoping ComputerSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string CSCreationClassName;

      [Key, Propagated ( "CIM_Process.CSName" ), Description (
          "The scoping ComputerSystem's Name."), 
       MaxLen ( 256 )]
   string CSName;

      [Key, Propagated ( "CIM_Process.OSCreationClassName" ), 
       Description (
          "The scoping OperatingSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string OSCreationClassName;

      [Key, Propagated ( "CIM_Process.OSName" ), Description (
          "The scoping OperatingSystem's Name."), 
       MaxLen ( 256 )]
   string OSName;

      [Key, Propagated ( "CIM_Process.CreationClassName" ), 
       Description (
          "The scoping Process' CreationClassName."), 
       MaxLen ( 256 )]
   string ProcessCreationClassName;

      [Key, Propagated ( "CIM_Process.Handle" ), Description (
          "The scoping Process' Handle."), 
       MaxLen ( 256 )]
   string ProcessHandle;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this property "
          "allow all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Description (
          "A string used to identify the Thread."), 
       MaxLen ( 256 )]
   string Handle;

      [Description (
          "Priority indicates the urgency or importance of execution "
          "of a Thread. A Thread may have a different priority than "
          "its owning Process. If this information is not available "
          "for a Thread, a value of 0 should be used.")]
   uint32 Priority;

      [Description (
          "Indicates the current operating condition of the Thread. "
          "Values include ready (2), running (3), and blocked (4), "
          "among others. The majority of the enumerated values are "
          "obvious. However, a few require additional explanation: \n"
          "7 (Ready but Relinquished Processor) describes that a "
          "thread is in the Ready state, but has voluntarily "
          "relinquished execution time to other threads. For example, "
          "this state may indicate a problem when the relinquishing "
          "thread is not handling items on its queues. If these "
          "semantics cannot be detected, the thread should report its "
          "state as 2 (\"Ready\"). \n"
          "8 (Hung) indicates that a thread is not responding."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8" }, 
       Values { "Unknown", "Other", "Ready", "Running", "Blocked",
          "Suspended Blocked", "Suspended Ready",
          "Ready But Relinquished Processor", "Hung" }]
   uint16 ExecutionState;

      [Description (
          "Time in kernel mode, in milliseconds. If this information "
          "is not available, a value of 0 should be used."), 
       Units ( "MilliSeconds" )]
   uint64 KernelModeTime;

      [Description (
          "Time in user mode, in milliseconds. If this information is "
          "not available, a value of 0 should be used."), 
       Units ( "MilliSeconds" )]
   uint64 UserModeTime;
};


// ===================================================================
// ProcessThread
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "A link between a Process and the Thread(s) running in the "
       "context of this Process.")]
class CIM_ProcessThread : CIM_Component {

      [Aggregate, Override ( "GroupComponent" ), Min ( 1 ), Max ( 1 ), 
       Description (
          "The Process.")]
   CIM_Process REF GroupComponent;

      [Override ( "PartComponent" ), Weak, Description (
          "The Thread running in the context of the Process.")]
   CIM_Thread REF PartComponent;
};

// ===================================================================
// JobSettingData
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "JobSettingData represents job characteristics and scheduling "
       "information for a CIM_Job. The settings may be applied to a "
       "job handling Service, a JobQueue or other destination to which "
       "jobs are submitted, and/or to individual CIM_Jobs. The "
       "applicability of the settings are defined using the "
       "ElementSettingData relationship. Since the Settings may be "
       "defined in several contexts and applied to many types of "
       "elements, this class is defined as a subclass of SettingData, "
       "versus ScopedSettingData.")]
class CIM_JobSettingData : CIM_SettingData {

      [Write, Description (
          "Number of times that a Job should be run. A value of 1 "
          "indicates that the Job is NOT recurring, while any non-zero "
          "value indicates a limit to the number of times that the Job "
          "will recur. Zero indicates that there is no limit to the "
          "number of times that the Job can be processed, but that it "
          "is terminated either AFTER the UntilTime, or by manual "
          "intervention. By default, a Job is processed once."), 
       ModelCorrespondence { "CIM_Job.JobRunTimes" }]
   uint32 JobRunTimes = 1;

      [Write, Description (
          "The month during which a Job should be processed. Specify 0 "
          "for January, 1 for February, and so on."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "January", "February", "March", "April", "May", "June",
          "July", "August", "September", "October", "November",
          "December" }, 
       ModelCorrespondence { "CIM_Job.RunMonth",
          "CIM_JobSettingData.RunDay",
          "CIM_JobSettingData.RunDayOfWeek",
          "CIM_JobSettingData.RunStartInterval" }]
   uint8 RunMonth;

      [Write, Description (
          "The day in the month on which a Job should be processed. "
          "There are two different interpretations for this property, "
          "depending on the value of RunDayOfWeek. In one case, RunDay "
          "defines the day-in-month on which the Job is processed. "
          "This interpretation is used when the RunDayOfWeek is 0. A "
          "positive or negative integer indicates whether the RunDay "
          "should be calculated from the beginning or the end of the "
          "month. For example, 5 indicates the fifth day in RunMonth "
          "and -1 indicates the last day in the RunMonth. \n"
          "\n"
          "When RunDayOfWeek is not 0, RunDay is the day-in-month on "
          "which the Job is processed, defined in conjunction with "
          "RunDayOfWeek. For example, if RunDay is 15 and RunDayOfWeek "
          "is Saturday, then the Job is processed on the first "
          "Saturday on or AFTER the 15th day in the RunMonth (e.g., "
          "the third Saturday in the month). If RunDay is 20 and "
          "RunDayOfWeek is -Saturday, then this indicates the first "
          "Saturday on or BEFORE the 20th day in the RunMonth. If "
          "RunDay is -1 and RunDayOfWeek is -Sunday, then this "
          "indicates the last Sunday in the RunMonth."), 
       MinValue ( -31 ), MaxValue ( 31 ), 
       ModelCorrespondence { "CIM_Job.RunDay",
          "CIM_JobSettingData.RunMonth",
          "CIM_JobSettingData.RunDayOfWeek",
          "CIM_JobSettingData.RunStartInterval" }]
   sint8 RunDay;

      [Write, Description (
          "Positive or negative integer used in conjunction with "
          "RunDay to indicate the day of the week on which a Job is "
          "processed. RunDayOfWeek is set to 0 to indicate an exact "
          "day of the month, such as March 1. A positive integer "
          "(representing Sunday, Monday, ..., Saturday) means that the "
          "day of week is found on or AFTER the specified RunDay. A "
          "negative integer (representing -Sunday, -Monday, ..., "
          "-Saturday) means that the day of week is found on or BEFORE "
          "the RunDay."), 
       ValueMap { "-7", "-6", "-5", "-4", "-3", "-2", "-1", "0", "1",
          "2", "3", "4", "5", "6", "7" }, 
       Values { "-Saturday", "-Friday", "-Thursday", "-Wednesday",
          "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
          "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
          "Friday", "Saturday" }, 
       ModelCorrespondence { "CIM_Job.RunDayOfWeek",
          "CIM_JobSettingData.RunMonth", "CIM_JobSettingData.RunDay",
          "CIM_JobSettingData.RunStartInterval" }]
   sint8 RunDayOfWeek;

      [Write, Description (
          "The time interval after midnight when a Job should be "
          "processed. For example, \n"
          "00000000020000.000000:000 \n"
          "indicates that the Job should be run on or after two "
          "o'clock, local time or UTC time (distinguished using the "
          "LocalOrUtcTime property."), 
       ModelCorrespondence { "CIM_Job.RunStartInterval",
          "CIM_JobSettingData.RunMonth", "CIM_JobSettingData.RunDay",
          "CIM_JobSettingData.RunDayOfWeek",
          "CIM_JobSettingData.LocalOrUtcTime" }]
   datetime RunStartInterval;

      [Write, Description (
          "This property indicates whether the times represented in "
          "the RunStartInterval and UntilTime properties represent "
          "local times or UTC times. Time values are synchronized "
          "worldwide by using the enumeration value 2, \"UTC Time\"."), 
       ValueMap { "1", "2" }, 
       Values { "Local Time", "UTC Time" }]
   uint16 LocalOrUtcTime;

      [Write, Description (
          "The setting for a Job's UntilTime - the time after which an "
          "executing Job should be stopped or not be allowed to "
          "proceed. This may be represented by an actual date and "
          "time, or an interval relative to the ScheduledStartTime. A "
          "value of all nines indicates that the Job can run "
          "indefinitely."), 
       ModelCorrespondence { "CIM_Job.UntilTime",
          "CIM_JobSettingData.LocalOrUtcTime" }]
   datetime UntilTime;

      [Write, Description (
          "The setting for a Job's Notify property - the user/email to "
          "be notified upon a scheduled Job's completion or failure."), 
       ModelCorrespondence { "CIM_Job.Notify" }]
   string Notify;

      [Write, Description (
          "The setting for a Job's Owner property - the user, service "
          "method, etc. that defined this setting data and causes the "
          "Job to be created."), 
       ModelCorrespondence { "CIM_Job.Owner" }]
   string Owner;

      [Write, Description (
          "Indicates the urgency or importance of execution of the "
          "Job, as specified by the user or defining entity. The "
          "actual Priority is found in the CIM_Job instance, "
          "associated via the ElementSettingData relationship. Unless "
          "otherwise specified, a lower number indicates a higher "
          "priority."), 
       ModelCorrespondence { "CIM_Job.Priority" }]
   uint32 Priority;

      [Write, Description (
          "Indicates whether or not the Job should be automatically "
          "deleted upon completion. Note that the 'completion' of a "
          "recurring job is defined by its JobRunTimes or UntilTime "
          "properties, OR when the Job is terminated by manual "
          "intervention."), 
       ModelCorrespondence { "CIM_Job.DeleteOnCompletion" }]
   boolean DeleteOnCompletion;

      [Description (
          "Describes the recovery setting if the Job does not "
          "unsuccessfully complete. The possible values are: \n"
          "0 = \"Unknown\", meaning it is unknown as to what recovery "
          "action to take \n"
          "1 = \"Other\", indicating that the recovery action will be "
          "specified in the property, OtherRecoveryAction \n"
          "2 = \"Do Not Continue\", meaning stop the execution of the "
          "job and appropriately update its status \n"
          "3 = \"Continue With Next Job\", meaning continue with the "
          "next job in the queue \n"
          "4 = \"Re-run Job\", indicating that the job should be "
          "re-run \n"
          "5 = \"Run Recovery Job\", meaning run the Job associated "
          "using the RecoveryJob relationship. Note that the recovery "
          "Job MUST already be on the queue from which it will run."), 
       ValueMap { "0", "1", "2", "3", "4", "5" }, 
       Values { "Unknown", "Other", "Do Not Continue",
          "Continue With Next Job", "Re-run Job", "Run Recovery Job" }, 
       ModelCorrespondence { "CIM_JobSettingData.OtherRecoveryAction",
          "CIM_Job.RecoveryAction" }]
   uint16 RecoveryAction;

      [Description (
          "A string describing the recovery action when the instance's "
          "RecoveryAction property is 1 (\"Other\")."), 
       ModelCorrespondence { "CIM_JobSettingData.RecoveryAction",
          "CIM_Job.OtherRecoveryAction" }]
   string OtherRecoveryAction;
};

// ===================================================================
// OwningJobElement
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "OwningJobElement represents an association between a Job and "
       "the ManagedElement responsible for the creation of the Job. "
       "This association may not be possible, given that the execution "
       "of jobs can move between systems and that the lifecycle of the "
       "creating entity may not persist for the total duration of the "
       "job. However, this can be very useful information when "
       "available. This association defines a more specific 'owner' "
       "than is provided by the CIM_Job.Owner string."), 
    ModelCorrespondence { "CIM_Job.Owner" }]
class CIM_OwningJobElement {

      [Key, Max ( 1 ), Description (
          "The ManagedElement responsible for the creation of the Job.")]
   CIM_ManagedElement REF OwningElement;

      [Key, Description (
          "The Job created by the ManagedElement.")]
   CIM_Job REF OwnedElement;
};


// ===================================================================
// AffectedJobElement
// ===================================================================
   [Association, Version ( "2.7.0" ), Description (
       "AffectedJobElement represents an association between a Job and "
       "the ManagedElement(s) that may be affected by its execution. "
       "It may not be feasible for the Job to describe all of the "
       "affected elements. The main purpose of this association is to "
       "provide information when a Job requires exclusive use of the "
       "'affected' ManagedElment(s) or when describing that side "
       "effects may result.")]
class CIM_AffectedJobElement {

      [Key, Description (
          "The ManagedElement affected by the execution of the Job.")]
   CIM_ManagedElement REF AffectedElement;

      [Key, Description (
          "The Job that is affecting the ManagedElement.")]
   CIM_Job REF AffectingElement;

      [Description (
          "An enumeration describing the 'effect' on the "
          "ManagedElement. This array corresponds to the "
          "OtherElementEffectsDescriptions array, where the latter "
          "provides details related to the high-level 'effects' "
          "enumerated by this property. Additional detail is required "
          "if the ElementEffects array contains the value 1, "
          "\"Other\"."), 
       ValueMap { "0", "1", "2", "3", "4" }, 
       Values { "Unknown", "Other", "Exclusive Use",
          "Performance Impact", "Element Integrity" },
          ArrayType ( "Indexed" ), 
       ModelCorrespondence { 
          "CIM_AffectedJobElement.OtherElementEffectsDescriptions" }]
   uint16 ElementEffects[];

      [Description (
          "Provides details for the 'effect' at the corresponding "
          "array position in ElementEffects. This information is "
          "required whenever ElementEffects contains the value 1 "
          "(\"Other\")."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_AffectedJobElement.ElementEffects" }]
   string OtherElementEffectsDescriptions[];
};


// ===================================================================
// ProcessOfJob
// ===================================================================
   [Association, Aggregation, Composition, Version ( "2.7.0" ), 
    Description (
       "ProcessOfJob describes that the referenced Process is the "
       "result of the execution of the Job. A Job may cause multiple "
       "Processes to run, perhaps on different operating systems. This "
       "is allowed by the '*' cardinality of the Process reference. "
       "Note that a Process can result from only one Job - hence, the "
       "'0..1' cardinality on Job.")]
class CIM_ProcessOfJob : CIM_Component {

      [Aggregate, Override ( "GroupComponent" ), Description (
          "Execution of the Job results in the creation of the Process "
          "referenced as PartComponent. The Job aggregates the "
          "Process(es) that are created when it is executed.")]
   CIM_Job REF GroupComponent;

      [Override ( "PartComponent" ), Description (
          "The Process that results from the execution of the Job.")]
   CIM_Process REF PartComponent;
};


// ===================================================================
// JobDestination
// ===================================================================
   [Version ( "2.7.0" ), Description (
       "JobDestination is an EnabledLogicalElement representing where "
       "a Job is submitted for processing. It can refer to a queue "
       "that contains zero or more Jobs, such as a print queue "
       "containing print Jobs. JobDestinations are hosted on Systems, "
       "similar to the way that Services are hosted on Systems. Also, "
       "they may be enabled/disabled similar to Services.")]
class CIM_JobDestination : CIM_EnabledLogicalElement {

      [Key, Propagated ( "CIM_System.CreationClassName" ), 
       Description (
          "The scoping System's CreationClassName."), 
       MaxLen ( 256 )]
   string SystemCreationClassName;

      [Key, Propagated ( "CIM_System.Name" ), Description (
          "The scoping System's Name."), 
       MaxLen ( 256 )]
   string SystemName;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Override ( "Name" ), Description (
          "The inherited Name serves as key of a JobDestination "
          "instance in a System."), 
       MaxLen ( 256 )]
   string Name;
};


// ===================================================================
// HostedJobDestination
// ===================================================================
   [Association, Version ( "2.8.0" ), Description (
       "An association between a JobDestination and a System on which "
       "it resides. The cardinality of this association is 1-to-many. "
       "A System may host many Job queues. Job Destinations are weak "
       "with respect to their hosting System. Heuristic: A "
       "JobDestination is hosted on the System where the "
       "LogicalDevices, SoftwareFeatures or Services that implement/ "
       "provide the JobDestination are located.")]
class CIM_HostedJobDestination : CIM_HostedDependency {

      [Override ( "Antecedent" ), Min ( 1 ), Max ( 1 ), Description (
          "The hosting System.")]
   CIM_System REF Antecedent;

      [Override ( "Dependent" ), Weak, Description (
          "The JobDestination hosted on the System.")]
   CIM_JobDestination REF Dependent;
};


// ===================================================================
// JobDestinationJobs
// ===================================================================
   [Association, Version ( "2.6.0" ), Description (
       "An association describing where a Job is submitted for "
       "processing, ie to which JobDestination.")]
class CIM_JobDestinationJobs : CIM_Dependency {

      [Override ( "Antecedent" ), Max ( 1 ), Description (
          "The JobDestination, possibly a queue.")]
   CIM_JobDestination REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Job that is in the Job queue/Destination.")]
   CIM_Job REF Dependent;
};

// ===================================================================
// JobProcessingStatistics
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "This class records the completion statistics (such as "
       "ElapsedTime) and other information for its associated Job. The "
       "class will be extended in a future release to include "
       "statistics regarding resource utilization. Note that there may "
       "be many instances of this class if the Job is recurring (i.e., "
       "if its JobRunTimes property is not 1).")]
class CIM_JobProcessingStatistics : CIM_StatisticalData {

      [Description (
          "The time that this invocation of the Job was started. This "
          "SHOULD be represented by an actual date and time, and not "
          "in interval format."), 
       ModelCorrespondence { "CIM_Job.StartTime" }]
   datetime StartTime;

      [Description (
          "The total execution time of the Job. This MUST be "
          "represented in interval format."), 
       ModelCorrespondence { "CIM_Job.ElapsedTime" }]
   datetime ElapsedTime;

      [Description (
          "Indicates the urgency or importance of execution of the "
          "Job. The lower the number, the higher the priority."), 
       ModelCorrespondence { "CIM_Job.Priority" }]
   uint32 Priority;

      [Description (
          "The percentage of the job that was completed at the time "
          "that the Job terminated. Note that this value will be less "
          "than 100 if the Job terminated prematurely. \n"
          "Note that the value 101 is undefined and will be not be "
          "allowed in the next major revision of the specification."), 
       Units ( "Percent" ), MinValue ( 0 ), MaxValue ( 101 ), 
       ModelCorrespondence { "CIM_Job.PercentComplete" }]
   uint16 PercentComplete;

      [Description (
          "Specifies the number of milliseconds of CPU that this job "
          "has used in its current (or last) run. When a job is "
          "actively running, this number will continue to change until "
          "the job has finished its execution, either successfully or "
          "unsuccessfully."), 
       Units ( "MilliSeconds" ), Counter, 
       ModelCorrespondence { "CIM_BatchJob.MaxCPUTime" }]
   uint32 CPUTimeUsed;

};

// ===================================================================
// JobQueue
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "Status and configuration of a JobQueue. Jobs are held on a "
       "queue, and can move from queue to queue until being processed.")]
class CIM_JobQueue : CIM_JobDestination {

      [Description (
          "Provides queue-specific status information, beyond the "
          "ManagedSystemElement.OperationalStatus property. This "
          "property further qualifies the status of the queue, or "
          "indicates a secondary condition (e.g. queue full)."), 
       ValueMap { "0", "1", "2", "3" }, 
       Values { "Unknown", "Other", "No Additional Status",
          "Queue Full" }, 
       ModelCorrespondence { "CIM_JobQueue.QueueStatusInfo" }]
   uint16 QueueStatus;

      [Description (
          "Provides a textual explanation for the status of the queue. "
          "Information about both QueueStatus and the "
          "OperationalStatus property (inherited from "
          "ManagedSystemElement) may be described in QueueStatusInfo. "
          "Note, however, that OperationalStatus' Descriptions (if "
          "available) MUST be provided in the StatusDescriptions "
          "array, inherited from ManagedSystemElement. This is where "
          "management clients will expect to locate this information."), 
       ModelCorrespondence { "CIM_JobQueue.QueueStatus" }]
   string QueueStatusInfo;

      [Write, Description (
          "Specifies the priority that will be assigned to a new Job "
          "being submitted to this queue, if the Job does not "
          "explicitly specify a priority. Note that lower numbers "
          "indicate higher priorities. The default value of 0xFFFF is "
          "the lowest priority.")]
   uint32 DefaultJobPriority = 65535;

      [Write, Description (
          "Specifies the maximum time (using a datetime interval "
          "format) that a Job can remain on this Queue before "
          "completing. If the MaxTimeOnQueue property is exceeded, "
          "then the Job SHOULD be removed from the Queue. A value of 0 "
          "(the default) indicates that there is no time limit.")]
   datetime MaxTimeOnQueue = "00000000000000.000000:000";

      [Write, Description (
          "Specifies the maximum number of Jobs that can reside on "
          "this Queue. A value of 0 (the default) indicates that there "
          "is no time limit.")]
   uint32 MaxJobsOnQueue = 0;

      [Write, Description (
          "Specifies the maximum number of milliseconds of CPU time "
          "that a Job queued to this destination can consume to "
          "complete its execution."), 
       Units ( "MilliSeconds" )]
   uint32 MaxJobCPUTime;
};


// ===================================================================
// QueueStatisticalData
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "The statistical data of a JobQueue. An instance of this class "
       "is associated with a specific JobQueue using the inherited "
       "ElementStatisticalData relationship.")]
class CIM_QueueStatisticalData : CIM_StatisticalData {

      [Description (
          "The number of Jobs whose MaxTimeOnQueue was exceeded. This "
          "would cause the Job to be removed from the Queue, and not "
          "processed to completion. This count begins at the time that "
          "the Queue was started/initialized."), 
       Counter]
   uint64 JobsMaxTimeExceeded;

      [Description (
          "Specifies the current number of Jobs that are in the "
          "running state, for the related Queue."), 
       Gauge]
   uint32 RunningJobs;

      [Description (
          "Specifies the current number of Jobs that are waiting to be "
          "put in the running state, for the related Queue."), 
       Gauge]
   uint32 WaitingJobs;
};

// ==================================================================
// RecoveryJob
// ==================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "CIM_RecoveryJob specifies the Job that should be run to clean "
       "up or recover from the unsuccessful completion of the "
       "Dependent Job.")]
class CIM_RecoveryJob : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "Antecedent represents the recovery Job.")]
   CIM_Job REF Antecedent;

      [Override ( "Dependent" ), Description (
          "Dependent represents the Job which may not successfully "
          "complete and which is dependent on the 'RecoveryJob' for "
          "cleanup.")]
   CIM_Job REF Dependent;
};

// ===================================================================
// BatchJob
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "Description of a batch request that is either waiting on a "
       "BatchQueue to run, in the process of running, or that has "
       "previously run. Jobs that are completed and not recurring will "
       "NOT be associated with a BatchQueue. Jobs that are completed "
       "but recurring WILL be associated with a BatchQueue, since they "
       "are waiting to run given the scheduling information in the "
       "associated JobSettingData instance.")]
class CIM_BatchJob : CIM_ConcreteJob {

      [Required, Override ( "Name" ), Description (
          "Uniquely identifies this Job within a BatchQueue and "
          "BatchService. This property can be used in the construction "
          "of the InstanceID key inherited from ConcreteJob.")]
   string Name;


      [Write, Description (
          "Specifies the maximum number of milliseconds of CPU time "
          "that this job can use in any individual run."), 
       Units ( "MilliSeconds" )]
   uint32 MaxCPUTime;

      [Description (
          "Time when this BatchJob was completed. This value is only "
          "valid if the inherited JobState property has been set to "
          "\"Completed\" (value=7), \"Terminated\" (value=8), or "
          "\"Killed\" (value=9)."), 
       ModelCorrespondence { "CIM_BatchJob.JobState" }]
   datetime TimeCompleted;

      [Write, Description (
          "Provides additional information, beyond Job Owner inherited "
          "from CIM_Job, to identify the origins of the BatchJob. This "
          "property could include information such as the System, "
          "application or Process that created the BatchJob.")]
   string JobOrigination;

      [Description (
          "Provides the command and parameters, in string form, for "
          "the execution of this job.")]
   string Task;
};

// ===================================================================
// BatchJobGroup
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "BatchJobGroup describes a collection of BatchJobs that are "
       "logically grouped. Two grouping/scheduling concepts are "
       "modeled: (1) User grouping: Jobs are logically grouped by the "
       "user of the batch system to capture common characteristics. "
       "There is no sequencing relationship between the jobs belonging "
       "to the Group. The jobs are grouped using the "
       "MemberOfCollection association. (2) Job sequencing: An ordered "
       "collection of jobs is defined where the jobs are executed in "
       "sequence. This captures a simple sequencing relationship for a "
       "set of jobs, where the order is defined using the "
       "AssignedSequence property of the OrderedMemberOfCollection "
       "association. An individual BacthJob can belong to multiple "
       "BatchJobGroups. \n"
       "\n"
       "If possible, an instance of OwningCollectionElement SHOULD be "
       "created for this JobGroup. However, this association might not "
       "exist, given that collections of jobs can move between systems "
       "as they execute, and the lifecycle of the owning/controlling "
       "entity is not necessarily persisted for the total duration of "
       "the collection. However, this can be very useful information "
       "when available.")]
class CIM_BatchJobGroup : CIM_Collection {

      [Key, 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"
          "\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.")]
   string InstanceID;

      [Description (
          "Describes the current status of this BatchJobGroup, based "
          "on the statuses of the jobs contained in the Group. The "
          "values of GroupStatus are more general than those of the "
          "individual jobs. The possible values are: \n"
          "0 = Unknown \n"
          "1 = Other \n"
          "2 = All jobs pending \n"
          "3 = Jobs in mixed states \n"
          "4 = All jobs completed \n"
          "Additional information MAY be specified in the Group "
          "StatusDescription property."), 
       ValueMap { "0", "1", "2", "3", "4" }, 
       Values { "Unknown", "Other", "All Jobs Pending",
          "Jobs in Mixed States", "All Jobs Completed" }, 
       ModelCorrespondence { "CIM_BatchJob.JobState",
          "CIM_BatchJobGroup.GroupStatusDescription" }]
   uint16 GroupStatus;

      [Description (
          "GroupStatusDescription provides additional information "
          "regarding the GroupStatus property."), 
       ModelCorrespondence { "CIM_BatchJobGroup.GroupStatus" }]
   string GroupStatusDescription;
};


// ===================================================================
// BatchSAP
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "The ServiceAccessPoint for accessing a BatchService. The "
       "relationship between the AccessPoint and the Service is "
       "described by instantiating the ServiceAccessBySAP association.")]
class CIM_BatchSAP : CIM_ServiceAccessPoint {

      [Description (
          "Specifies the batch submission procotols that this "
          "AccessPoint uses. Note that each entry of this array is "
          "related to the corresponding entry in the BatchProtocolInfo "
          "array that is located at the same index."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unknown", "Other", "Local" }, ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_BatchSAP.BatchProtocolInfo" }]
   uint16 BatchProtocol[];

      [Description (
          "Provides clarifying or additional information about the "
          "protocols supported by this AccessPoint. Note, each entry "
          "of this array is related to the corresponding entry in the "
          "BatchProtocol array that is located at the same index."), 
       ArrayType ( "Indexed" ), 
       ModelCorrespondence { "CIM_BatchSAP.BatchProtocol" }]
   string BatchProtocolInfo[];
};


// ===================================================================
// BatchService
// ===================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "The Service that provides support for processing BatchJob "
       "requests. The basic assumption of this model is that a "
       "BatchService accepts a BatchJob for processing, via its "
       "BatchSAP. The Job is then placed on a BatchQueue (indicated by "
       "the QueueForBatchService association). A System takes Jobs "
       "from Queues (indicated by the ExecutionTarget association) and "
       "processes them.")]
class CIM_BatchService : CIM_Service {
};


// ===================================================================
// QueueForBatchService
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "This association indicates that a BatchService utilizes a "
       "particular JobQueue, to hold jobs submitted to the Service. At "
       "any point in time, the JobQueue can be full or otherwise not "
       "accepting jobs from the BatchService. This situation is "
       "indicated by the QueueAcceptingFromService Boolean property in "
       "this association.")]
class CIM_QueueForBatchService : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The BatchQueue that the Service utilizes.")]
   CIM_JobQueue REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The BatchService that puts BatchJobs on the Queue.")]
   CIM_BatchService REF Dependent;

      [Description (
          "Indicates that the BatchService can place jobs on the "
          "Queue.")]
   boolean QueueAcceptingFromService;
};


// ===================================================================
// ExecutionCandidate
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "ExecutionCandidate represents the association between a System "
       "and a Job, describing that the System is capable of running "
       "the job.")]
class CIM_ExecutionCandidate : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The System that is capable of running the Job.")]
   CIM_System REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Job that can be run.")]
   CIM_Job REF Dependent;
};


// ===================================================================
// ExecutionTarget
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "ExecutionTarget represents the association between a System "
       "and a Job, describing that the System is running the job.")]
class CIM_ExecutionTarget : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The System that is running the Job.")]
   CIM_System REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Job that is run.")]
   CIM_Job REF Dependent;
};


// ===================================================================
// ExecutionRequirement
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "ExecutionRequirement represents the restriction of a job to a "
       "specific set of nodes, processors, etc. that are aggregated "
       "into a ConcreteCollection.")]
class CIM_ExecutionRequirement : CIM_Dependency {

      [Override ( "Antecedent" ), Description (
          "The ConcreteCollection that is required to run the Job.")]
   CIM_ConcreteCollection REF Antecedent;

      [Override ( "Dependent" ), Description (
          "The Job that can be run.")]
   CIM_Job REF Dependent;
};

// ==================================================================
// MethodResult
// ==================================================================
   [Experimental, Version ( "2.8.1000" ), Description (
       "Jobs are sometimes used to represent extrinsic method "
       "invocations that execute for times longer than the length of "
       "time is reasonable to require a client to wait. The method "
       "executing continues beyond the method return to the client. "
       "The class provides the result of the execution of a Job that "
       "was itself started by the side-effect of this extrinsic method "
       "invocation. \n"
       "The indication instances embedded an instance of this class "
       "MUST be the same indications delivered to listening clients or "
       "recorded, all or in part, to logs. Basically, this approach is "
       "a corollary to the functionality provided by an instance of "
       "ListenerDestinationLog (as defined in the Interop Model). The "
       "latter provides a comprehensive, persistent mechanism for "
       "recording Job results, but is also more resource-intensive and "
       "requires supporting logging functionality. Both the extra "
       "resources and logging MAY NOT be available in all environments "
       "(for example, embedded environments). Therefore, this "
       "instance-based approach is also provided. \n"
       "The MethodResult instances MUST NOT exist after the associated "
       "ConcreteJob is deleted.")]
class CIM_MethodResult : CIM_ManagedElement {

      [Key, 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;

      [Description (
          "This property contains a CIM_InstMethodCall Indication that "
          "describes the pre-execution values of the extrinisic method "
          "invocation."), 
       EmbeddedInstance ( "CIM_InstCIMMethodCall" )]
   string PreCallIndication;

      [Description (
          "This property contains a CIM_InstMethodCall Indication that "
          "describes the post-execution values of the extrinisic "
          "method invocation."), 
       EmbeddedInstance ( "CIM_InstCIMMethodCall" )]
   string PostCallIndication;

};

// ===================================================================
// AssociatedJobMethodResult
// ===================================================================
   [Association, Experimental, Version ( "2.8.1000" ), Description (
       "AssociatedJobMethodResult represents an association between a "
       "ConcreteJob and the MethodResult expressing the parameters for "
       "the Job when the job was created by side-effect of the "
       "execution of an extrinsic method.")]
class CIM_AssociatedJobMethodResult {

      [Key, Max ( 1 ), Description (
          "The associated ConcreteJob.")]
   CIM_ConcreteJob REF Job;

      [Key, Max ( 1 ), Description (
          "The associated MethodResult.")]
   CIM_MethodResult REF JobParameters;
};

// ===================================================================
// end of file
// ===================================================================
