#ifndef MINING_CORE_MODULE_IDL
#define MINING_CORE_MODULE_IDL
#pragma prefix "org.omg.cwm.analysis"
#include "Reflective.idl"
#include "CoreModule.idl"
#include "TransformationModule.idl"

module MiningCoreModule
{
   typedef sequence<CoreModule::UmlAttribute> UmlAttributeSet;
   typedef sequence<CoreModule::UmlAttribute> UmlAttributeUList;
   typedef sequence<CoreModule::Class> ClassSet;
   interface MiningCoreModulePackage;

   module MiningDataModule
   {
      interface AttributeAssignmentClass;
      interface AttributeAssignment;
      typedef sequence<AttributeAssignment> AttributeAssignmentSet;
      interface AttributeAssignmentSetClass;
      interface AttributeAssignmentSet;
      typedef sequence<AttributeAssignmentSet> AttributeAssignmentSetSet;
      interface AttributeUsageClass;
      interface AttributeUsage;
      typedef sequence<AttributeUsage> AttributeUsageSet;
      interface AttributeUsageSetClass;
      interface AttributeUsageSet;
      typedef sequence<AttributeUsageSet> AttributeUsageSetSet;
      interface CategoricalAttributePropertiesClass;
      interface CategoricalAttributeProperties;
      typedef sequence<CategoricalAttributeProperties> CategoricalAttributePropertiesSet;
      interface DirectAttributeAssignmentClass;
      interface DirectAttributeAssignment;
      typedef sequence<DirectAttributeAssignment> DirectAttributeAssignmentSet;
      interface MiningAttributeClass;
      interface MiningAttribute;
      typedef sequence<MiningAttribute> MiningAttributeSet;
      interface LogicalAttributeClass;
      interface LogicalAttribute;
      typedef sequence<LogicalAttribute> LogicalAttributeSet;
      interface LogicalDataClass;
      interface LogicalData;
      typedef sequence<LogicalData> LogicalDataSet;
      interface NumericalAttributePropertiesClass;
      interface NumericalAttributeProperties;
      typedef sequence<NumericalAttributeProperties> NumericalAttributePropertiesSet;
      interface OrdinalAttributePropertiesClass;
      interface OrdinalAttributeProperties;
      typedef sequence<OrdinalAttributeProperties> OrdinalAttributePropertiesSet;
      interface PhysicalDataClass;
      interface PhysicalData;
      typedef sequence<PhysicalData> PhysicalDataSet;
      interface PivotAttributeAssignmentClass;
      interface PivotAttributeAssignment;
      typedef sequence<PivotAttributeAssignment> PivotAttributeAssignmentSet;
      interface ReversePivotAttributeAssignmentClass;
      interface ReversePivotAttributeAssignment;
      typedef sequence<ReversePivotAttributeAssignment> ReversePivotAttributeAssignmentSet;
      interface SetAttributeAssignmentClass;
      interface SetAttributeAssignment;
      typedef sequence<SetAttributeAssignment> SetAttributeAssignmentSet;
      interface CategoryClass;
      interface Category;
      typedef sequence<Category> CategorySet;
      typedef sequence<Category> CategoryUList;
      interface CategoryMapClass;
      interface CategoryMap;
      typedef sequence<CategoryMap> CategoryMapSet;
      interface CategoryMapObjectClass;
      interface CategoryMapObject;
      typedef sequence<CategoryMapObject> CategoryMapObjectSet;
      interface CategoryMapObjectEntryClass;
      interface CategoryMapObjectEntry;
      typedef sequence<CategoryMapObjectEntry> CategoryMapObjectEntrySet;
      interface CategoryMapTableClass;
      interface CategoryMapTable;
      typedef sequence<CategoryMapTable> CategoryMapTableSet;
      interface CategoryMatrixClass;
      interface CategoryMatrix;
      typedef sequence<CategoryMatrix> CategoryMatrixSet;
      interface CategoryMatrixEntryClass;
      interface CategoryMatrixEntry;
      typedef sequence<CategoryMatrixEntry> CategoryMatrixEntrySet;
      interface CategoryMatrixObjectClass;
      interface CategoryMatrixObject;
      typedef sequence<CategoryMatrixObject> CategoryMatrixObjectSet;
      interface CategoryMatrixTableClass;
      interface CategoryMatrixTable;
      typedef sequence<CategoryMatrixTable> CategoryMatrixTableSet;
      interface CategoryTaxonomyClass;
      interface CategoryTaxonomy;
      typedef sequence<CategoryTaxonomy> CategoryTaxonomySet;
      interface MiningDataModulePackage;
      enum AttributeSelectionFunction {isNotNull, isNull, isOne, isZero, isTrue, isFalse};
      enum AttributeType {categorical, ordinal, numerical, notSpecified};
      enum OrderType {asIs, alphabetical, numeric, date};
      enum UsageOption {active, supplementary, target};
      enum ValueSelectionFunction {vsf_value, vsf_attribute};
      enum CategoryProperty {valid, invalid, missing};
      enum MatrixProperty {mp_symmetric, mp_diagonal, mp_any};

      interface AttributeAssignmentClass : CoreModule::ModelElementClass
      {
         readonly attribute AttributeAssignmentSet all_of_type_attribute_assignment;
         readonly attribute AttributeAssignmentSet all_of_class_attribute_assignment;
         AttributeAssignment create_attribute_assignment (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface AttributeAssignment : AttributeAssignmentClass, CoreModule::ModelElement
      {
         UmlAttributeUList order_id_attribute ()
            raises (Reflective::MofError);
         void set_order_id_attribute (in UmlAttributeUList new_value)
            raises (Reflective::MofError);
         void unset_order_id_attribute ()
            raises (Reflective::MofError);
         void add_order_id_attribute (in CoreModule::UmlAttribute new_element)
            raises (Reflective::MofError);
         void add_order_id_attribute_before (
            in CoreModule::UmlAttribute new_element,
            in CoreModule::UmlAttribute before_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_order_id_attribute (
            in CoreModule::UmlAttribute old_element,
            in CoreModule::UmlAttribute new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_order_id_attribute (in CoreModule::UmlAttribute old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningAttributeSet logical_attribute ()
            raises (Reflective::MofError);
         void set_logical_attribute (in MiningAttributeSet new_value)
            raises (Reflective::MofError);
         void add_logical_attribute (in MiningAttribute new_element)
            raises (Reflective::MofError);
         void modify_logical_attribute (
            in MiningAttribute old_element,
            in MiningAttribute new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_logical_attribute (in MiningAttribute old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AttributeAssignment

      interface AttributeAssignmentSetClass : CoreModule::ModelElementClass
      {
         readonly attribute AttributeAssignmentSetSet all_of_type_attribute_assignment_set;
         readonly attribute AttributeAssignmentSetSet all_of_class_attribute_assignment_set;
         AttributeAssignmentSet create_attribute_assignment_set (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface AttributeAssignmentSet : AttributeAssignmentSetClass, CoreModule::ModelElement
      {
         AttributeAssignmentSet assignment ()
            raises (Reflective::MofError);
         void set_assignment (in AttributeAssignmentSet new_value)
            raises (Reflective::MofError);
         void add_assignment (in AttributeAssignment new_element)
            raises (Reflective::MofError);
         void modify_assignment (
            in AttributeAssignment old_element,
            in AttributeAssignment new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_assignment (in AttributeAssignment old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AttributeAssignmentSet

      interface AttributeUsageClass : CoreModule::FeatureClass
      {
         readonly attribute AttributeUsageSet all_of_type_attribute_usage;
         readonly attribute AttributeUsageSet all_of_class_attribute_usage;
         AttributeUsage create_attribute_usage (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in UsageOption usage,
            in double weight,
            in boolean suppress_discretization,
            in boolean suppress_normalization)
            raises (Reflective::MofError);
      };

      interface AttributeUsage : AttributeUsageClass, CoreModule::Feature
      {
         UsageOption usage ()
            raises (Reflective::MofError);
         void set_usage (in UsageOption new_value)
            raises (Reflective::MofError);
         double weight ()
            raises (Reflective::MofError);
         void set_weight (in double new_value)
            raises (Reflective::MofError);
         LogicalAttributeSet uml_attribute ()
            raises (Reflective::MofError);
         void set_uml_attribute (in LogicalAttributeSet new_value)
            raises (Reflective::MofError);
         void add_uml_attribute (in LogicalAttribute new_element)
            raises (Reflective::MofError);
         void modify_uml_attribute (
            in LogicalAttribute old_element,
            in LogicalAttribute new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_uml_attribute (in LogicalAttribute old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         boolean suppress_discretization ()
            raises (Reflective::MofError);
         void set_suppress_discretization (in boolean new_value)
            raises (Reflective::MofError);
         boolean suppress_normalization ()
            raises (Reflective::MofError);
         void set_suppress_normalization (in boolean new_value)
            raises (Reflective::MofError);
      }; // end of interface AttributeUsage

      interface AttributeUsageSetClass : CoreModule::ClassClass
      {
         readonly attribute AttributeUsageSetSet all_of_type_attribute_usage_set;
         readonly attribute AttributeUsageSetSet all_of_class_attribute_usage_set;
         AttributeUsageSet create_attribute_usage_set (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_abstract)
            raises (Reflective::MofError);
      };

      interface AttributeUsageSet : AttributeUsageSetClass, CoreModule::Class
      {
      }; // end of interface AttributeUsageSet

      interface CategoricalAttributePropertiesClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoricalAttributePropertiesSet all_of_type_categorical_attribute_properties;
         readonly attribute CategoricalAttributePropertiesSet all_of_class_categorical_attribute_properties;
         CategoricalAttributeProperties create_categorical_attribute_properties (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface CategoricalAttributeProperties : CategoricalAttributePropertiesClass, CoreModule::ModelElement
      {
         CategoryUList category ()
            raises (Reflective::MofError);
         void set_category (in CategoryUList new_value)
            raises (Reflective::MofError);
         void unset_category ()
            raises (Reflective::MofError);
         void add_category (in MiningDataModule::Category new_element)
            raises (Reflective::MofError);
         void add_category_before (
            in MiningDataModule::Category new_element,
            in MiningDataModule::Category before_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_category (
            in MiningDataModule::Category old_element,
            in MiningDataModule::Category new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_category (in MiningDataModule::Category old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         CategoryTaxonomy taxonomy ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_taxonomy (in CategoryTaxonomy new_value)
            raises (Reflective::MofError);
         void unset_taxonomy ()
            raises (Reflective::MofError);
      }; // end of interface CategoricalAttributeProperties

      interface DirectAttributeAssignmentClass : AttributeAssignmentClass
      {
         readonly attribute DirectAttributeAssignmentSet all_of_type_direct_attribute_assignment;
         readonly attribute DirectAttributeAssignmentSet all_of_class_direct_attribute_assignment;
         DirectAttributeAssignment create_direct_attribute_assignment (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface DirectAttributeAssignment : DirectAttributeAssignmentClass, AttributeAssignment
      {
         CoreModule::UmlAttribute uml_attribute ()
            raises (Reflective::MofError);
         void set_uml_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
      }; // end of interface DirectAttributeAssignment

      interface MiningAttributeClass : CoreModule::UmlAttributeClass
      {
         readonly attribute MiningAttributeSet all_of_type_mining_attribute;
      };

      interface MiningAttribute : MiningAttributeClass, CoreModule::UmlAttribute
      {
         string display_name ()
            raises (Reflective::MofError);
         void set_display_name (in string new_value)
            raises (Reflective::MofError);
         AttributeType attribute_type ()
            raises (Reflective::MofError);
         void set_attribute_type (in AttributeType new_value)
            raises (Reflective::MofError);
      }; // end of interface MiningAttribute

      interface LogicalAttributeClass : MiningAttributeClass
      {
         readonly attribute LogicalAttributeSet all_of_type_logical_attribute;
         readonly attribute LogicalAttributeSet all_of_class_logical_attribute;
         LogicalAttribute create_logical_attribute (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in AttributeType attribute_type,
            in boolean is_set_valued)
            raises (Reflective::MofError);
      };

      interface LogicalAttribute : LogicalAttributeClass, MiningAttribute
      {
         boolean is_set_valued ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_is_set_valued (in boolean new_value)
            raises (Reflective::MofError);
         void unset_is_set_valued ()
            raises (Reflective::MofError);
         CategoricalAttributeProperties categorical_properties ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_categorical_properties (in CategoricalAttributeProperties new_value)
            raises (Reflective::MofError);
         void unset_categorical_properties ()
            raises (Reflective::MofError);
         NumericalAttributeProperties numerical_properties ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_numerical_properties (in NumericalAttributeProperties new_value)
            raises (Reflective::MofError);
         void unset_numerical_properties ()
            raises (Reflective::MofError);
      }; // end of interface LogicalAttribute

      interface LogicalDataClass : CoreModule::ClassClass
      {
         readonly attribute LogicalDataSet all_of_type_logical_data;
         readonly attribute LogicalDataSet all_of_class_logical_data;
         LogicalData create_logical_data (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_abstract)
            raises (Reflective::MofError);
      };

      interface LogicalData : LogicalDataClass, CoreModule::Class
      {
      }; // end of interface LogicalData

      interface NumericalAttributePropertiesClass : CoreModule::ModelElementClass
      {
         readonly attribute NumericalAttributePropertiesSet all_of_type_numerical_attribute_properties;
         readonly attribute NumericalAttributePropertiesSet all_of_class_numerical_attribute_properties;
         NumericalAttributeProperties create_numerical_attribute_properties (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in double lower_bound,
            in double upper_bound,
            in boolean is_discrete,
            in boolean is_cyclic,
            in double anchor,
            in double cycle_begin,
            in double cycle_end,
            in double discrete_step_size)
            raises (Reflective::MofError);
      };

      interface NumericalAttributeProperties : NumericalAttributePropertiesClass, CoreModule::ModelElement
      {
         double lower_bound ()
            raises (Reflective::MofError);
         void set_lower_bound (in double new_value)
            raises (Reflective::MofError);
         double upper_bound ()
            raises (Reflective::MofError);
         void set_upper_bound (in double new_value)
            raises (Reflective::MofError);
         boolean is_discrete ()
            raises (Reflective::MofError);
         void set_is_discrete (in boolean new_value)
            raises (Reflective::MofError);
         boolean is_cyclic ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_is_cyclic (in boolean new_value)
            raises (Reflective::MofError);
         void unset_is_cyclic ()
            raises (Reflective::MofError);
         double anchor ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_anchor (in double new_value)
            raises (Reflective::MofError);
         void unset_anchor ()
            raises (Reflective::MofError);
         double cycle_begin ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_cycle_begin (in double new_value)
            raises (Reflective::MofError);
         void unset_cycle_begin ()
            raises (Reflective::MofError);
         double cycle_end ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_cycle_end (in double new_value)
            raises (Reflective::MofError);
         void unset_cycle_end ()
            raises (Reflective::MofError);
         double discrete_step_size ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_discrete_step_size (in double new_value)
            raises (Reflective::MofError);
         void unset_discrete_step_size ()
            raises (Reflective::MofError);
      }; // end of interface NumericalAttributeProperties

      interface OrdinalAttributePropertiesClass : CategoricalAttributePropertiesClass
      {
         readonly attribute OrdinalAttributePropertiesSet all_of_type_ordinal_attribute_properties;
         readonly attribute OrdinalAttributePropertiesSet all_of_class_ordinal_attribute_properties;
         OrdinalAttributeProperties create_ordinal_attribute_properties (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in OrderType order_type,
            in boolean is_cyclic)
            raises (Reflective::MofError);
      };

      interface OrdinalAttributeProperties : OrdinalAttributePropertiesClass, CategoricalAttributeProperties
      {
         OrderType order_type ()
            raises (Reflective::MofError);
         void set_order_type (in OrderType new_value)
            raises (Reflective::MofError);
         boolean is_cyclic ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_is_cyclic (in boolean new_value)
            raises (Reflective::MofError);
         void unset_is_cyclic ()
            raises (Reflective::MofError);
      }; // end of interface OrdinalAttributeProperties

      interface PhysicalDataClass : CoreModule::ModelElementClass
      {
         readonly attribute PhysicalDataSet all_of_type_physical_data;
         readonly attribute PhysicalDataSet all_of_class_physical_data;
         PhysicalData create_physical_data (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface PhysicalData : PhysicalDataClass, CoreModule::ModelElement
      {
         CoreModule::Class source ()
            raises (Reflective::MofError);
         void set_source (in CoreModule::Class new_value)
            raises (Reflective::MofError);
      }; // end of interface PhysicalData

      interface PivotAttributeAssignmentClass : AttributeAssignmentClass
      {
         readonly attribute PivotAttributeAssignmentSet all_of_type_pivot_attribute_assignment;
         readonly attribute PivotAttributeAssignmentSet all_of_class_pivot_attribute_assignment;
         PivotAttributeAssignment create_pivot_attribute_assignment (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface PivotAttributeAssignment : PivotAttributeAssignmentClass, AttributeAssignment
      {
         CoreModule::UmlAttribute set_id_attribute ()
            raises (Reflective::MofError);
         void set_set_id_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute name_attribute ()
            raises (Reflective::MofError);
         void set_name_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute value_attribute ()
            raises (Reflective::MofError);
         void set_value_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
      }; // end of interface PivotAttributeAssignment

      interface ReversePivotAttributeAssignmentClass : AttributeAssignmentClass
      {
         readonly attribute ReversePivotAttributeAssignmentSet all_of_type_reverse_pivot_attribute_assignment;
         readonly attribute ReversePivotAttributeAssignmentSet all_of_class_reverse_pivot_attribute_assignment;
         ReversePivotAttributeAssignment create_reverse_pivot_attribute_assignment (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in AttributeSelectionFunction attribute_selection_function,
            in ValueSelectionFunction value_selection_function)
            raises (Reflective::MofError);
      };

      interface ReversePivotAttributeAssignment : ReversePivotAttributeAssignmentClass, AttributeAssignment
      {
         UmlAttributeSet selector_attribute ()
            raises (Reflective::MofError);
         void set_selector_attribute (in UmlAttributeSet new_value)
            raises (Reflective::MofError);
         void add_selector_attribute (in CoreModule::UmlAttribute new_element)
            raises (Reflective::MofError);
         void modify_selector_attribute (
            in CoreModule::UmlAttribute old_element,
            in CoreModule::UmlAttribute new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_selector_attribute (in CoreModule::UmlAttribute old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         AttributeSelectionFunction attribute_selection_function ()
            raises (Reflective::MofError);
         void set_attribute_selection_function (in AttributeSelectionFunction new_value)
            raises (Reflective::MofError);
         ValueSelectionFunction value_selection_function ()
            raises (Reflective::MofError);
         void set_value_selection_function (in ValueSelectionFunction new_value)
            raises (Reflective::MofError);
      }; // end of interface ReversePivotAttributeAssignment

      interface SetAttributeAssignmentClass : AttributeAssignmentClass
      {
         readonly attribute SetAttributeAssignmentSet all_of_type_set_attribute_assignment;
         readonly attribute SetAttributeAssignmentSet all_of_class_set_attribute_assignment;
         SetAttributeAssignment create_set_attribute_assignment (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface SetAttributeAssignment : SetAttributeAssignmentClass, AttributeAssignment
      {
         CoreModule::UmlAttribute set_id_attribute ()
            raises (Reflective::MofError);
         void set_set_id_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute member_attribute ()
            raises (Reflective::MofError);
         void set_member_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
      }; // end of interface SetAttributeAssignment

      interface CategoryClass : CoreModule::ModelElementClass
      {
         readonly attribute CategorySet all_of_type_category;
         readonly attribute CategorySet all_of_class_category;
         Category create_category (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in any value,
            in boolean is_null_category,
            in string display_name,
            in CategoryProperty property,
            in double prior)
            raises (Reflective::MofError);
      };

      interface Category : CategoryClass, CoreModule::ModelElement
      {
         any value ()
            raises (Reflective::MofError);
         void set_value (in any new_value)
            raises (Reflective::MofError);
         boolean is_null_category ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_is_null_category (in boolean new_value)
            raises (Reflective::MofError);
         void unset_is_null_category ()
            raises (Reflective::MofError);
         string display_name ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_display_name (in string new_value)
            raises (Reflective::MofError);
         void unset_display_name ()
            raises (Reflective::MofError);
         CategoryProperty property ()
            raises (Reflective::MofError);
         void set_property (in CategoryProperty new_value)
            raises (Reflective::MofError);
         double prior ()
            raises (Reflective::MofError);
         void set_prior (in double new_value)
            raises (Reflective::MofError);
      }; // end of interface Category

      interface CategoryMapClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoryMapSet all_of_type_category_map;
         readonly attribute CategoryMapSet all_of_class_category_map;
         CategoryMap create_category_map (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_multi_level,
            in boolean is_item_map)
            raises (Reflective::MofError);
      };

      interface CategoryMap : CategoryMapClass, CoreModule::ModelElement
      {
         boolean is_multi_level ()
            raises (Reflective::MofError);
         void set_is_multi_level (in boolean new_value)
            raises (Reflective::MofError);
         boolean is_item_map ()
            raises (Reflective::MofError);
         void set_is_item_map (in boolean new_value)
            raises (Reflective::MofError);
      }; // end of interface CategoryMap

      interface CategoryMapObjectClass : CoreModule::ModelElementClass, CategoryMapClass
      {
         readonly attribute CategoryMapObjectSet all_of_type_category_map_object;
         readonly attribute CategoryMapObjectSet all_of_class_category_map_object;
         CategoryMapObject create_category_map_object (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_multi_level,
            in boolean is_item_map)
            raises (Reflective::MofError);
      };

      interface CategoryMapObject : CategoryMapObjectClass, CoreModule::ModelElement, CategoryMap
      {
         CategoryMapObjectEntrySet entry ()
            raises (Reflective::MofError);
         void set_entry (in CategoryMapObjectEntrySet new_value)
            raises (Reflective::MofError);
         void unset_entry ()
            raises (Reflective::MofError);
         void add_entry (in CategoryMapObjectEntry new_element)
            raises (Reflective::MofError);
         void modify_entry (
            in CategoryMapObjectEntry old_element,
            in CategoryMapObjectEntry new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_entry (in CategoryMapObjectEntry old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMapObject

      interface CategoryMapObjectEntryClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoryMapObjectEntrySet all_of_type_category_map_object_entry;
         readonly attribute CategoryMapObjectEntrySet all_of_class_category_map_object_entry;
         CategoryMapObjectEntry create_category_map_object_entry (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in any graph_id)
            raises (Reflective::MofError);
      };

      interface CategoryMapObjectEntry : CategoryMapObjectEntryClass, CoreModule::ModelElement
      {
         Category child ()
            raises (Reflective::MofError);
         void set_child (in Category new_value)
            raises (Reflective::MofError);
         CategorySet parent ()
            raises (Reflective::MofError);
         void set_parent (in CategorySet new_value)
            raises (Reflective::MofError);
         void add_parent (in Category new_element)
            raises (Reflective::MofError);
         void modify_parent (
            in Category old_element,
            in Category new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_parent (in Category old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         any graph_id ()
            raises (Reflective::MofError);
         void set_graph_id (in any new_value)
            raises (Reflective::MofError);
      }; // end of interface CategoryMapObjectEntry

      interface CategoryMapTableClass : CoreModule::ModelElementClass, CategoryMapClass
      {
         readonly attribute CategoryMapTableSet all_of_type_category_map_table;
         readonly attribute CategoryMapTableSet all_of_class_category_map_table;
         CategoryMapTable create_category_map_table (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_multi_level,
            in boolean is_item_map)
            raises (Reflective::MofError);
      };

      interface CategoryMapTable : CategoryMapTableClass, CoreModule::ModelElement, CategoryMap
      {
         CoreModule::UmlAttribute child_attribute ()
            raises (Reflective::MofError);
         void set_child_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute parent_attribute ()
            raises (Reflective::MofError);
         void set_parent_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute graph_id_attribute ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_graph_id_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         void unset_graph_id_attribute ()
            raises (Reflective::MofError);
         CoreModule::Class table ()
            raises (Reflective::MofError);
         void set_table (in CoreModule::Class new_value)
            raises (Reflective::MofError);
      }; // end of interface CategoryMapTable

      interface CategoryMatrixClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoryMatrixSet all_of_type_category_matrix;
         readonly attribute CategoryMatrixSet all_of_class_category_matrix;
         CategoryMatrix create_category_matrix (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in double diagonal_default,
            in double off_diagonal_default,
            in MatrixProperty kind)
            raises (Reflective::MofError);
      };

      interface CategoryMatrix : CategoryMatrixClass, CoreModule::ModelElement
      {
         double diagonal_default ()
            raises (Reflective::MofError);
         void set_diagonal_default (in double new_value)
            raises (Reflective::MofError);
         double off_diagonal_default ()
            raises (Reflective::MofError);
         void set_off_diagonal_default (in double new_value)
            raises (Reflective::MofError);
         MatrixProperty kind ()
            raises (Reflective::MofError);
         void set_kind (in MatrixProperty new_value)
            raises (Reflective::MofError);
         CategorySet category ()
            raises (Reflective::MofError);
         void set_category (in CategorySet new_value)
            raises (Reflective::MofError);
         void add_category (in MiningDataModule::Category new_element)
            raises (Reflective::MofError);
         void modify_category (
            in MiningDataModule::Category old_element,
            in MiningDataModule::Category new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_category (in MiningDataModule::Category old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMatrix

      interface CategoryMatrixEntryClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoryMatrixEntrySet all_of_type_category_matrix_entry;
         readonly attribute CategoryMatrixEntrySet all_of_class_category_matrix_entry;
         CategoryMatrixEntry create_category_matrix_entry (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in double value)
            raises (Reflective::MofError);
      };

      interface CategoryMatrixEntry : CategoryMatrixEntryClass, CoreModule::ModelElement
      {
         Category row_index ()
            raises (Reflective::MofError);
         void set_row_index (in Category new_value)
            raises (Reflective::MofError);
         Category column_index ()
            raises (Reflective::MofError);
         void set_column_index (in Category new_value)
            raises (Reflective::MofError);
         double value ()
            raises (Reflective::MofError);
         void set_value (in double new_value)
            raises (Reflective::MofError);
      }; // end of interface CategoryMatrixEntry

      interface CategoryMatrixObjectClass : CategoryMatrixClass
      {
         readonly attribute CategoryMatrixObjectSet all_of_type_category_matrix_object;
         readonly attribute CategoryMatrixObjectSet all_of_class_category_matrix_object;
         CategoryMatrixObject create_category_matrix_object (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in double diagonal_default,
            in double off_diagonal_default,
            in MatrixProperty kind)
            raises (Reflective::MofError);
      };

      interface CategoryMatrixObject : CategoryMatrixObjectClass, CategoryMatrix
      {
         CategoryMatrixEntrySet entry ()
            raises (Reflective::MofError);
         void set_entry (in CategoryMatrixEntrySet new_value)
            raises (Reflective::MofError);
         void unset_entry ()
            raises (Reflective::MofError);
         void add_entry (in CategoryMatrixEntry new_element)
            raises (Reflective::MofError);
         void modify_entry (
            in CategoryMatrixEntry old_element,
            in CategoryMatrixEntry new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_entry (in CategoryMatrixEntry old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMatrixObject

      interface CategoryMatrixTableClass : CategoryMatrixClass
      {
         readonly attribute CategoryMatrixTableSet all_of_type_category_matrix_table;
         readonly attribute CategoryMatrixTableSet all_of_class_category_matrix_table;
         CategoryMatrixTable create_category_matrix_table (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in double diagonal_default,
            in double off_diagonal_default,
            in MatrixProperty kind)
            raises (Reflective::MofError);
      };

      interface CategoryMatrixTable : CategoryMatrixTableClass, CategoryMatrix
      {
         CoreModule::UmlAttribute row_attribute ()
            raises (Reflective::MofError);
         void set_row_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute column_attribute ()
            raises (Reflective::MofError);
         void set_column_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute value_attribute ()
            raises (Reflective::MofError);
         void set_value_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         ClassSet source ()
            raises (Reflective::MofError);
         void set_source (in ClassSet new_value)
            raises (Reflective::MofError);
         void unset_source ()
            raises (Reflective::MofError);
         void add_source (in CoreModule::Class new_element)
            raises (Reflective::MofError);
         void modify_source (
            in CoreModule::Class old_element,
            in CoreModule::Class new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_source (in CoreModule::Class old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMatrixTable

      interface CategoryTaxonomyClass : CoreModule::ModelElementClass
      {
         readonly attribute CategoryTaxonomySet all_of_type_category_taxonomy;
         readonly attribute CategoryTaxonomySet all_of_class_category_taxonomy;
         CategoryTaxonomy create_category_taxonomy (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface CategoryTaxonomy : CategoryTaxonomyClass, CoreModule::ModelElement
      {
         CategoryMapSet category_map ()
            raises (Reflective::MofError);
         void set_category_map (in CategoryMapSet new_value)
            raises (Reflective::MofError);
         void unset_category_map ()
            raises (Reflective::MofError);
         void add_category_map (in CategoryMap new_element)
            raises (Reflective::MofError);
         void modify_category_map (
            in CategoryMap old_element,
            in CategoryMap new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_category_map (in CategoryMap old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         CategorySet root_category ()
            raises (Reflective::MofError);
         void set_root_category (in CategorySet new_value)
            raises (Reflective::MofError);
         void unset_root_category ()
            raises (Reflective::MofError);
         void add_root_category (in Category new_element)
            raises (Reflective::MofError);
         void modify_root_category (
            in Category old_element,
            in Category new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_root_category (in Category old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryTaxonomy

      struct PhysicalDataRefSourceLink
      {
         CoreModule::Class source;
         PhysicalData physical_data;
      };
      typedef sequence<PhysicalDataRefSourceLink> PhysicalDataRefSourceLinkSet;

      interface PhysicalDataRefSource : Reflective::RefAssociation
      {
         PhysicalDataRefSourceLinkSet all_physical_data_ref_source_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::Class source,
            in PhysicalData physical_data)
            raises (Reflective::MofError);
         CoreModule::Class source (in PhysicalData physical_data)
            raises (Reflective::MofError);
         void add (
            in CoreModule::Class source,
            in PhysicalData physical_data)
            raises (Reflective::MofError);
         void modify_source (
            in CoreModule::Class source,
            in PhysicalData physical_data,
            in CoreModule::Class new_source)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::Class source,
            in PhysicalData physical_data)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface PhysicalDataRefSource

      struct LogicalAttrHasCategoricalPropertiesLink
      {
         CategoricalAttributeProperties categorical_properties;
         LogicalAttribute logical_attribute;
      };
      typedef sequence<LogicalAttrHasCategoricalPropertiesLink> LogicalAttrHasCategoricalPropertiesLinkSet;

      interface LogicalAttrHasCategoricalProperties : Reflective::RefAssociation
      {
         LogicalAttrHasCategoricalPropertiesLinkSet all_logical_attr_has_categorical_properties_links()
            raises (Reflective::MofError);
         boolean exists (
            in CategoricalAttributeProperties categorical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         CategoricalAttributeProperties categorical_properties (in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         LogicalAttribute logical_attribute (in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         void add (
            in CategoricalAttributeProperties categorical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         void modify_categorical_properties (
            in CategoricalAttributeProperties categorical_properties,
            in LogicalAttribute logical_attribute,
            in CategoricalAttributeProperties new_categorical_properties)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_logical_attribute (
            in CategoricalAttributeProperties categorical_properties,
            in LogicalAttribute logical_attribute,
            in LogicalAttribute new_logical_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CategoricalAttributeProperties categorical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface LogicalAttrHasCategoricalProperties

      struct LogicalAttrHasNumericalPropertiesLink
      {
         NumericalAttributeProperties numerical_properties;
         LogicalAttribute logical_attribute;
      };
      typedef sequence<LogicalAttrHasNumericalPropertiesLink> LogicalAttrHasNumericalPropertiesLinkSet;

      interface LogicalAttrHasNumericalProperties : Reflective::RefAssociation
      {
         LogicalAttrHasNumericalPropertiesLinkSet all_logical_attr_has_numerical_properties_links()
            raises (Reflective::MofError);
         boolean exists (
            in NumericalAttributeProperties numerical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         NumericalAttributeProperties numerical_properties (in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         LogicalAttribute logical_attribute (in NumericalAttributeProperties numerical_properties)
            raises (Reflective::MofError);
         void add (
            in NumericalAttributeProperties numerical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::MofError);
         void modify_numerical_properties (
            in NumericalAttributeProperties numerical_properties,
            in LogicalAttribute logical_attribute,
            in NumericalAttributeProperties new_numerical_properties)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_logical_attribute (
            in NumericalAttributeProperties numerical_properties,
            in LogicalAttribute logical_attribute,
            in LogicalAttribute new_logical_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in NumericalAttributeProperties numerical_properties,
            in LogicalAttribute logical_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface LogicalAttrHasNumericalProperties

      struct CategoricalPropertiesRefTaxonomyLink
      {
         CategoryTaxonomy taxonomy;
         CategoricalAttributeProperties categorical_properties;
      };
      typedef sequence<CategoricalPropertiesRefTaxonomyLink> CategoricalPropertiesRefTaxonomyLinkSet;

      interface CategoricalPropertiesRefTaxonomy : Reflective::RefAssociation
      {
         CategoricalPropertiesRefTaxonomyLinkSet all_categorical_properties_ref_taxonomy_links()
            raises (Reflective::MofError);
         boolean exists (
            in CategoryTaxonomy taxonomy,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         CategoryTaxonomy taxonomy (in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         void add (
            in CategoryTaxonomy taxonomy,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         void modify_taxonomy (
            in CategoryTaxonomy taxonomy,
            in CategoricalAttributeProperties categorical_properties,
            in CategoryTaxonomy new_taxonomy)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CategoryTaxonomy taxonomy,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoricalPropertiesRefTaxonomy

      struct CategoricalPropertiesHasCategoriesLink
      {
         MiningDataModule::Category category;
         CategoricalAttributeProperties categorical_properties;
      };
      typedef sequence<CategoricalPropertiesHasCategoriesLink> CategoricalPropertiesHasCategoriesLinkSet;

      interface CategoricalPropertiesHasCategories : Reflective::RefAssociation
      {
         CategoricalPropertiesHasCategoriesLinkSet all_categorical_properties_has_categories_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         CategoryUList category (in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         CategoricalAttributeProperties categorical_properties (in MiningDataModule::Category category)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::MofError);
         void add_before_category (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties,
            in MiningDataModule::Category before)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_category (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties,
            in MiningDataModule::Category new_category)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_categorical_properties (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties,
            in CategoricalAttributeProperties new_categorical_properties)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::Category category,
            in CategoricalAttributeProperties categorical_properties)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoricalPropertiesHasCategories

      struct AssignmentRefLogicalAttributeLink
      {
         MiningAttribute logical_attribute;
         AttributeAssignment attr_assignment;
      };
      typedef sequence<AssignmentRefLogicalAttributeLink> AssignmentRefLogicalAttributeLinkSet;

      interface AssignmentRefLogicalAttribute : Reflective::RefAssociation
      {
         AssignmentRefLogicalAttributeLinkSet all_assignment_ref_logical_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningAttribute logical_attribute,
            in AttributeAssignment attr_assignment)
            raises (Reflective::MofError);
         MiningAttributeSet logical_attribute (in AttributeAssignment attr_assignment)
            raises (Reflective::MofError);
         void add (
            in MiningAttribute logical_attribute,
            in AttributeAssignment attr_assignment)
            raises (Reflective::MofError);
         void modify_logical_attribute (
            in MiningAttribute logical_attribute,
            in AttributeAssignment attr_assignment,
            in MiningAttribute new_logical_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningAttribute logical_attribute,
            in AttributeAssignment attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AssignmentRefLogicalAttribute

      struct AssignmentRefOrderIdAttributeLink
      {
         CoreModule::UmlAttribute order_id_attribute;
         AttributeAssignment attr_assignmnet;
      };
      typedef sequence<AssignmentRefOrderIdAttributeLink> AssignmentRefOrderIdAttributeLinkSet;

      interface AssignmentRefOrderIdAttribute : Reflective::RefAssociation
      {
         AssignmentRefOrderIdAttributeLinkSet all_assignment_ref_order_id_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute order_id_attribute,
            in AttributeAssignment attr_assignmnet)
            raises (Reflective::MofError);
         UmlAttributeUList order_id_attribute (in AttributeAssignment attr_assignmnet)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute order_id_attribute,
            in AttributeAssignment attr_assignmnet)
            raises (Reflective::MofError);
         void add_before_order_id_attribute (
            in CoreModule::UmlAttribute order_id_attribute,
            in AttributeAssignment attr_assignmnet,
            in CoreModule::UmlAttribute before)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_order_id_attribute (
            in CoreModule::UmlAttribute order_id_attribute,
            in AttributeAssignment attr_assignmnet,
            in CoreModule::UmlAttribute new_order_id_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute order_id_attribute,
            in AttributeAssignment attr_assignmnet)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AssignmentRefOrderIdAttribute

      struct PivotRefSetIdAttributeLink
      {
         CoreModule::UmlAttribute set_id_attribute;
         PivotAttributeAssignment pivot_attr_assignment;
      };
      typedef sequence<PivotRefSetIdAttributeLink> PivotRefSetIdAttributeLinkSet;

      interface PivotRefSetIdAttribute : Reflective::RefAssociation
      {
         PivotRefSetIdAttributeLinkSet all_pivot_ref_set_id_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute set_id_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute set_id_attribute (in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute set_id_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         void modify_set_id_attribute (
            in CoreModule::UmlAttribute set_id_attribute,
            in PivotAttributeAssignment pivot_attr_assignment,
            in CoreModule::UmlAttribute new_set_id_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute set_id_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface PivotRefSetIdAttribute

      struct PivotRefNameAttributeLink
      {
         CoreModule::UmlAttribute name_attribute;
         PivotAttributeAssignment pivot_attr_assignment;
      };
      typedef sequence<PivotRefNameAttributeLink> PivotRefNameAttributeLinkSet;

      interface PivotRefNameAttribute : Reflective::RefAssociation
      {
         PivotRefNameAttributeLinkSet all_pivot_ref_name_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute name_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute name_attribute (in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute name_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::MofError);
         void modify_name_attribute (
            in CoreModule::UmlAttribute name_attribute,
            in PivotAttributeAssignment pivot_attr_assignment,
            in CoreModule::UmlAttribute new_name_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute name_attribute,
            in PivotAttributeAssignment pivot_attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface PivotRefNameAttribute

      struct PivotRefValueAttributeLink
      {
         CoreModule::UmlAttribute value_attribute;
         PivotAttributeAssignment pivot_attr_assignmnet;
      };
      typedef sequence<PivotRefValueAttributeLink> PivotRefValueAttributeLinkSet;

      interface PivotRefValueAttribute : Reflective::RefAssociation
      {
         PivotRefValueAttributeLinkSet all_pivot_ref_value_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute value_attribute,
            in PivotAttributeAssignment pivot_attr_assignmnet)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute value_attribute (in PivotAttributeAssignment pivot_attr_assignmnet)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute value_attribute,
            in PivotAttributeAssignment pivot_attr_assignmnet)
            raises (Reflective::MofError);
         void modify_value_attribute (
            in CoreModule::UmlAttribute value_attribute,
            in PivotAttributeAssignment pivot_attr_assignmnet,
            in CoreModule::UmlAttribute new_value_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute value_attribute,
            in PivotAttributeAssignment pivot_attr_assignmnet)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface PivotRefValueAttribute

      struct SetAssignmentRefSetIdAttrLink
      {
         CoreModule::UmlAttribute set_id_attribute;
         SetAttributeAssignment set_attr_assignment;
      };
      typedef sequence<SetAssignmentRefSetIdAttrLink> SetAssignmentRefSetIdAttrLinkSet;

      interface SetAssignmentRefSetIdAttr : Reflective::RefAssociation
      {
         SetAssignmentRefSetIdAttrLinkSet all_set_assignment_ref_set_id_attr_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute set_id_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute set_id_attribute (in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute set_id_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         void modify_set_id_attribute (
            in CoreModule::UmlAttribute set_id_attribute,
            in SetAttributeAssignment set_attr_assignment,
            in CoreModule::UmlAttribute new_set_id_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute set_id_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SetAssignmentRefSetIdAttr

      struct SetAssignmentRefMemberAttrLink
      {
         CoreModule::UmlAttribute member_attribute;
         SetAttributeAssignment set_attr_assignment;
      };
      typedef sequence<SetAssignmentRefMemberAttrLink> SetAssignmentRefMemberAttrLinkSet;

      interface SetAssignmentRefMemberAttr : Reflective::RefAssociation
      {
         SetAssignmentRefMemberAttrLinkSet all_set_assignment_ref_member_attr_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute member_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute member_attribute (in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute member_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::MofError);
         void modify_member_attribute (
            in CoreModule::UmlAttribute member_attribute,
            in SetAttributeAssignment set_attr_assignment,
            in CoreModule::UmlAttribute new_member_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute member_attribute,
            in SetAttributeAssignment set_attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SetAssignmentRefMemberAttr

      struct ReversePivotRefAttributeLink
      {
         CoreModule::UmlAttribute selector_attribute;
         ReversePivotAttributeAssignment reverse_pivot_attr_assignment;
      };
      typedef sequence<ReversePivotRefAttributeLink> ReversePivotRefAttributeLinkSet;

      interface ReversePivotRefAttribute : Reflective::RefAssociation
      {
         ReversePivotRefAttributeLinkSet all_reverse_pivot_ref_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute selector_attribute,
            in ReversePivotAttributeAssignment reverse_pivot_attr_assignment)
            raises (Reflective::MofError);
         UmlAttributeSet selector_attribute (in ReversePivotAttributeAssignment reverse_pivot_attr_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute selector_attribute,
            in ReversePivotAttributeAssignment reverse_pivot_attr_assignment)
            raises (Reflective::MofError);
         void modify_selector_attribute (
            in CoreModule::UmlAttribute selector_attribute,
            in ReversePivotAttributeAssignment reverse_pivot_attr_assignment,
            in CoreModule::UmlAttribute new_selector_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute selector_attribute,
            in ReversePivotAttributeAssignment reverse_pivot_attr_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ReversePivotRefAttribute

      struct DirectAssignmentRefAttributeLink
      {
         CoreModule::UmlAttribute uml_attribute;
         DirectAttributeAssignment direct_attribute_assignment;
      };
      typedef sequence<DirectAssignmentRefAttributeLink> DirectAssignmentRefAttributeLinkSet;

      interface DirectAssignmentRefAttribute : Reflective::RefAssociation
      {
         DirectAssignmentRefAttributeLinkSet all_direct_assignment_ref_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute uml_attribute,
            in DirectAttributeAssignment direct_attribute_assignment)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute uml_attribute (in DirectAttributeAssignment direct_attribute_assignment)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute uml_attribute,
            in DirectAttributeAssignment direct_attribute_assignment)
            raises (Reflective::MofError);
         void modify_uml_attribute (
            in CoreModule::UmlAttribute uml_attribute,
            in DirectAttributeAssignment direct_attribute_assignment,
            in CoreModule::UmlAttribute new_uml_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute uml_attribute,
            in DirectAttributeAssignment direct_attribute_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface DirectAssignmentRefAttribute

      struct UsageRefAttributeLink
      {
         LogicalAttribute uml_attribute;
         AttributeUsage usage;
      };
      typedef sequence<UsageRefAttributeLink> UsageRefAttributeLinkSet;

      interface UsageRefAttribute : Reflective::RefAssociation
      {
         UsageRefAttributeLinkSet all_usage_ref_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in LogicalAttribute uml_attribute,
            in AttributeUsage usage)
            raises (Reflective::MofError);
         LogicalAttributeSet uml_attribute (in AttributeUsage usage)
            raises (Reflective::MofError);
         void add (
            in LogicalAttribute uml_attribute,
            in AttributeUsage usage)
            raises (Reflective::MofError);
         void modify_uml_attribute (
            in LogicalAttribute uml_attribute,
            in AttributeUsage usage,
            in LogicalAttribute new_uml_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in LogicalAttribute uml_attribute,
            in AttributeUsage usage)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface UsageRefAttribute

      struct AssignmentSetHasAssignmentLink
      {
         AttributeAssignment assignment;
         AttributeAssignmentSet set;
      };
      typedef sequence<AssignmentSetHasAssignmentLink> AssignmentSetHasAssignmentLinkSet;

      interface AssignmentSetHasAssignment : Reflective::RefAssociation
      {
         AssignmentSetHasAssignmentLinkSet all_assignment_set_has_assignment_links()
            raises (Reflective::MofError);
         boolean exists (
            in AttributeAssignment assignment,
            in AttributeAssignmentSet set)
            raises (Reflective::MofError);
         AttributeAssignmentSet assignment (in AttributeAssignmentSet set)
            raises (Reflective::MofError);
         AttributeAssignmentSet set (in AttributeAssignment assignment)
            raises (Reflective::MofError);
         void add (
            in AttributeAssignment assignment,
            in AttributeAssignmentSet set)
            raises (Reflective::MofError);
         void modify_assignment (
            in AttributeAssignment assignment,
            in AttributeAssignmentSet set,
            in AttributeAssignment new_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_set (
            in AttributeAssignment assignment,
            in AttributeAssignmentSet set,
            in AttributeAssignmentSet new_set)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in AttributeAssignment assignment,
            in AttributeAssignmentSet set)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AssignmentSetHasAssignment

      struct CategoryMapObjectHasEntryLink
      {
         CategoryMapObjectEntry entry;
         CategoryMapObject map_object;
      };
      typedef sequence<CategoryMapObjectHasEntryLink> CategoryMapObjectHasEntryLinkSet;

      interface CategoryMapObjectHasEntry : Reflective::RefAssociation
      {
         CategoryMapObjectHasEntryLinkSet all_category_map_object_has_entry_links()
            raises (Reflective::MofError);
         boolean exists (
            in CategoryMapObjectEntry entry,
            in CategoryMapObject map_object)
            raises (Reflective::MofError);
         CategoryMapObjectEntrySet entry (in CategoryMapObject map_object)
            raises (Reflective::MofError);
         CategoryMapObject map_object (in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         void add (
            in CategoryMapObjectEntry entry,
            in CategoryMapObject map_object)
            raises (Reflective::MofError);
         void modify_entry (
            in CategoryMapObjectEntry entry,
            in CategoryMapObject map_object,
            in CategoryMapObjectEntry new_entry)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_map_object (
            in CategoryMapObjectEntry entry,
            in CategoryMapObject map_object,
            in CategoryMapObject new_map_object)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CategoryMapObjectEntry entry,
            in CategoryMapObject map_object)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMapObjectHasEntry

      struct TaxonomyHasCategoryMapLink
      {
         CategoryMap category_map;
         CategoryTaxonomy taxonomy;
      };
      typedef sequence<TaxonomyHasCategoryMapLink> TaxonomyHasCategoryMapLinkSet;

      interface TaxonomyHasCategoryMap : Reflective::RefAssociation
      {
         TaxonomyHasCategoryMapLinkSet all_taxonomy_has_category_map_links()
            raises (Reflective::MofError);
         boolean exists (
            in CategoryMap category_map,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         CategoryMapSet category_map (in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         CategoryTaxonomySet taxonomy (in CategoryMap category_map)
            raises (Reflective::MofError);
         void add (
            in CategoryMap category_map,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         void modify_category_map (
            in CategoryMap category_map,
            in CategoryTaxonomy taxonomy,
            in CategoryMap new_category_map)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_taxonomy (
            in CategoryMap category_map,
            in CategoryTaxonomy taxonomy,
            in CategoryTaxonomy new_taxonomy)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CategoryMap category_map,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TaxonomyHasCategoryMap

      struct MapEntryRefChildCategoryLink
      {
         Category child;
         CategoryMapObjectEntry entry;
      };
      typedef sequence<MapEntryRefChildCategoryLink> MapEntryRefChildCategoryLinkSet;

      interface MapEntryRefChildCategory : Reflective::RefAssociation
      {
         MapEntryRefChildCategoryLinkSet all_map_entry_ref_child_category_links()
            raises (Reflective::MofError);
         boolean exists (
            in Category child,
            in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         Category child (in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         void add (
            in Category child,
            in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         void modify_child (
            in Category child,
            in CategoryMapObjectEntry entry,
            in Category new_child)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in Category child,
            in CategoryMapObjectEntry entry)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MapEntryRefChildCategory

      struct MatrixEntryRefColumnIndexLink
      {
         Category column_index;
         CategoryMatrixEntry category_entry;
      };
      typedef sequence<MatrixEntryRefColumnIndexLink> MatrixEntryRefColumnIndexLinkSet;

      interface MatrixEntryRefColumnIndex : Reflective::RefAssociation
      {
         MatrixEntryRefColumnIndexLinkSet all_matrix_entry_ref_column_index_links()
            raises (Reflective::MofError);
         boolean exists (
            in Category column_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         Category column_index (in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         void add (
            in Category column_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         void modify_column_index (
            in Category column_index,
            in CategoryMatrixEntry category_entry,
            in Category new_column_index)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in Category column_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixEntryRefColumnIndex

      struct MatrixObjectHasEntryLink
      {
         CategoryMatrixEntry entry;
         CategoryMatrixObject category_matrix;
      };
      typedef sequence<MatrixObjectHasEntryLink> MatrixObjectHasEntryLinkSet;

      interface MatrixObjectHasEntry : Reflective::RefAssociation
      {
         MatrixObjectHasEntryLinkSet all_matrix_object_has_entry_links()
            raises (Reflective::MofError);
         boolean exists (
            in CategoryMatrixEntry entry,
            in CategoryMatrixObject category_matrix)
            raises (Reflective::MofError);
         CategoryMatrixEntrySet entry (in CategoryMatrixObject category_matrix)
            raises (Reflective::MofError);
         CategoryMatrixObject category_matrix (in CategoryMatrixEntry entry)
            raises (Reflective::MofError);
         void add (
            in CategoryMatrixEntry entry,
            in CategoryMatrixObject category_matrix)
            raises (Reflective::MofError);
         void modify_entry (
            in CategoryMatrixEntry entry,
            in CategoryMatrixObject category_matrix,
            in CategoryMatrixEntry new_entry)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_category_matrix (
            in CategoryMatrixEntry entry,
            in CategoryMatrixObject category_matrix,
            in CategoryMatrixObject new_category_matrix)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CategoryMatrixEntry entry,
            in CategoryMatrixObject category_matrix)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixObjectHasEntry

      struct MapEntryRefParentCategoryLink
      {
         Category parent;
         CategoryMapObjectEntry entry;
      };
      typedef sequence<MapEntryRefParentCategoryLink> MapEntryRefParentCategoryLinkSet;

      interface MapEntryRefParentCategory : Reflective::RefAssociation
      {
         MapEntryRefParentCategoryLinkSet all_map_entry_ref_parent_category_links()
            raises (Reflective::MofError);
         boolean exists (
            in Category parent,
            in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         CategorySet parent (in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         void add (
            in Category parent,
            in CategoryMapObjectEntry entry)
            raises (Reflective::MofError);
         void modify_parent (
            in Category parent,
            in CategoryMapObjectEntry entry,
            in Category new_parent)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in Category parent,
            in CategoryMapObjectEntry entry)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MapEntryRefParentCategory

      struct TaxonomyRefRootCategoryLink
      {
         Category root_category;
         CategoryTaxonomy taxonomy;
      };
      typedef sequence<TaxonomyRefRootCategoryLink> TaxonomyRefRootCategoryLinkSet;

      interface TaxonomyRefRootCategory : Reflective::RefAssociation
      {
         TaxonomyRefRootCategoryLinkSet all_taxonomy_ref_root_category_links()
            raises (Reflective::MofError);
         boolean exists (
            in Category root_category,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         CategorySet root_category (in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         void add (
            in Category root_category,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         void modify_root_category (
            in Category root_category,
            in CategoryTaxonomy taxonomy,
            in Category new_root_category)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in Category root_category,
            in CategoryTaxonomy taxonomy)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TaxonomyRefRootCategory

      struct MatrixEntryRefRowIndexLink
      {
         Category row_index;
         CategoryMatrixEntry category_entry;
      };
      typedef sequence<MatrixEntryRefRowIndexLink> MatrixEntryRefRowIndexLinkSet;

      interface MatrixEntryRefRowIndex : Reflective::RefAssociation
      {
         MatrixEntryRefRowIndexLinkSet all_matrix_entry_ref_row_index_links()
            raises (Reflective::MofError);
         boolean exists (
            in Category row_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         Category row_index (in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         void add (
            in Category row_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::MofError);
         void modify_row_index (
            in Category row_index,
            in CategoryMatrixEntry category_entry,
            in Category new_row_index)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in Category row_index,
            in CategoryMatrixEntry category_entry)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixEntryRefRowIndex

      struct MatrixTableRefSourceLink
      {
         CoreModule::Class source;
         CategoryMatrixTable matrix_table;
      };
      typedef sequence<MatrixTableRefSourceLink> MatrixTableRefSourceLinkSet;

      interface MatrixTableRefSource : Reflective::RefAssociation
      {
         MatrixTableRefSourceLinkSet all_matrix_table_ref_source_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::Class source,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         ClassSet source (in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void add (
            in CoreModule::Class source,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void modify_source (
            in CoreModule::Class source,
            in CategoryMatrixTable matrix_table,
            in CoreModule::Class new_source)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::Class source,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixTableRefSource

      struct MapTableRefChildAttributeLink
      {
         CoreModule::UmlAttribute child_attribute;
         CategoryMapTable map;
      };
      typedef sequence<MapTableRefChildAttributeLink> MapTableRefChildAttributeLinkSet;

      interface MapTableRefChildAttribute : Reflective::RefAssociation
      {
         MapTableRefChildAttributeLinkSet all_map_table_ref_child_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute child_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute child_attribute (in CategoryMapTable map)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute child_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         void modify_child_attribute (
            in CoreModule::UmlAttribute child_attribute,
            in CategoryMapTable map,
            in CoreModule::UmlAttribute new_child_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute child_attribute,
            in CategoryMapTable map)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MapTableRefChildAttribute

      struct CategoryMapRefClassLink
      {
         CoreModule::Class table;
         CategoryMapTable map_table;
      };
      typedef sequence<CategoryMapRefClassLink> CategoryMapRefClassLinkSet;

      interface CategoryMapRefClass : Reflective::RefAssociation
      {
         CategoryMapRefClassLinkSet all_category_map_ref_class_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::Class table,
            in CategoryMapTable map_table)
            raises (Reflective::MofError);
         CoreModule::Class table (in CategoryMapTable map_table)
            raises (Reflective::MofError);
         void add (
            in CoreModule::Class table,
            in CategoryMapTable map_table)
            raises (Reflective::MofError);
         void modify_table (
            in CoreModule::Class table,
            in CategoryMapTable map_table,
            in CoreModule::Class new_table)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::Class table,
            in CategoryMapTable map_table)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CategoryMapRefClass

      struct MatrixTableRefColumnAttrLink
      {
         CoreModule::UmlAttribute column_attribute;
         CategoryMatrixTable matrix_table;
      };
      typedef sequence<MatrixTableRefColumnAttrLink> MatrixTableRefColumnAttrLinkSet;

      interface MatrixTableRefColumnAttr : Reflective::RefAssociation
      {
         MatrixTableRefColumnAttrLinkSet all_matrix_table_ref_column_attr_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute column_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute column_attribute (in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute column_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void modify_column_attribute (
            in CoreModule::UmlAttribute column_attribute,
            in CategoryMatrixTable matrix_table,
            in CoreModule::UmlAttribute new_column_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute column_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixTableRefColumnAttr

      struct MapTableRefGraphIdAttributeLink
      {
         CoreModule::UmlAttribute graph_id_attribute;
         CategoryMapTable map;
      };
      typedef sequence<MapTableRefGraphIdAttributeLink> MapTableRefGraphIdAttributeLinkSet;

      interface MapTableRefGraphIdAttribute : Reflective::RefAssociation
      {
         MapTableRefGraphIdAttributeLinkSet all_map_table_ref_graph_id_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute graph_id_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute graph_id_attribute (in CategoryMapTable map)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute graph_id_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         void modify_graph_id_attribute (
            in CoreModule::UmlAttribute graph_id_attribute,
            in CategoryMapTable map,
            in CoreModule::UmlAttribute new_graph_id_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute graph_id_attribute,
            in CategoryMapTable map)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MapTableRefGraphIdAttribute

      struct MatrixRefIndexLabelsLink
      {
         MiningDataModule::Category category;
         CategoryMatrix category_matrix;
      };
      typedef sequence<MatrixRefIndexLabelsLink> MatrixRefIndexLabelsLinkSet;

      interface MatrixRefIndexLabels : Reflective::RefAssociation
      {
         MatrixRefIndexLabelsLinkSet all_matrix_ref_index_labels_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::Category category,
            in CategoryMatrix category_matrix)
            raises (Reflective::MofError);
         CategorySet category (in CategoryMatrix category_matrix)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::Category category,
            in CategoryMatrix category_matrix)
            raises (Reflective::MofError);
         void modify_category (
            in MiningDataModule::Category category,
            in CategoryMatrix category_matrix,
            in MiningDataModule::Category new_category)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::Category category,
            in CategoryMatrix category_matrix)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixRefIndexLabels

      struct MapTableRefParentAttributeLink
      {
         CoreModule::UmlAttribute parent_attribute;
         CategoryMapTable map;
      };
      typedef sequence<MapTableRefParentAttributeLink> MapTableRefParentAttributeLinkSet;

      interface MapTableRefParentAttribute : Reflective::RefAssociation
      {
         MapTableRefParentAttributeLinkSet all_map_table_ref_parent_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute parent_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute parent_attribute (in CategoryMapTable map)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute parent_attribute,
            in CategoryMapTable map)
            raises (Reflective::MofError);
         void modify_parent_attribute (
            in CoreModule::UmlAttribute parent_attribute,
            in CategoryMapTable map,
            in CoreModule::UmlAttribute new_parent_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute parent_attribute,
            in CategoryMapTable map)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MapTableRefParentAttribute

      struct MatrixTableRefRowAttrLink
      {
         CoreModule::UmlAttribute row_attribute;
         CategoryMatrixTable matrix_table;
      };
      typedef sequence<MatrixTableRefRowAttrLink> MatrixTableRefRowAttrLinkSet;

      interface MatrixTableRefRowAttr : Reflective::RefAssociation
      {
         MatrixTableRefRowAttrLinkSet all_matrix_table_ref_row_attr_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute row_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute row_attribute (in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute row_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void modify_row_attribute (
            in CoreModule::UmlAttribute row_attribute,
            in CategoryMatrixTable matrix_table,
            in CoreModule::UmlAttribute new_row_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute row_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixTableRefRowAttr

      struct MatrixTableRefValueAttrLink
      {
         CoreModule::UmlAttribute value_attribute;
         CategoryMatrixTable matrix_table;
      };
      typedef sequence<MatrixTableRefValueAttrLink> MatrixTableRefValueAttrLinkSet;

      interface MatrixTableRefValueAttr : Reflective::RefAssociation
      {
         MatrixTableRefValueAttrLinkSet all_matrix_table_ref_value_attr_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute value_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute value_attribute (in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute value_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::MofError);
         void modify_value_attribute (
            in CoreModule::UmlAttribute value_attribute,
            in CategoryMatrixTable matrix_table,
            in CoreModule::UmlAttribute new_value_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute value_attribute,
            in CategoryMatrixTable matrix_table)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MatrixTableRefValueAttr

      interface MiningDataModulePackage : Reflective::RefPackage
      {
         readonly attribute AttributeAssignmentClass attribute_assignment_ref;
         readonly attribute AttributeAssignmentSetClass attribute_assignment_set_ref;
         readonly attribute AttributeUsageClass attribute_usage_ref;
         readonly attribute AttributeUsageSetClass attribute_usage_set_ref;
         readonly attribute CategoricalAttributePropertiesClass categorical_attribute_properties_ref;
         readonly attribute DirectAttributeAssignmentClass direct_attribute_assignment_ref;
         readonly attribute MiningAttributeClass mining_attribute_ref;
         readonly attribute LogicalAttributeClass logical_attribute_ref;
         readonly attribute LogicalDataClass logical_data_ref;
         readonly attribute NumericalAttributePropertiesClass numerical_attribute_properties_ref;
         readonly attribute OrdinalAttributePropertiesClass ordinal_attribute_properties_ref;
         readonly attribute PhysicalDataClass physical_data_ref;
         readonly attribute PivotAttributeAssignmentClass pivot_attribute_assignment_ref;
         readonly attribute ReversePivotAttributeAssignmentClass reverse_pivot_attribute_assignment_ref;
         readonly attribute SetAttributeAssignmentClass set_attribute_assignment_ref;
         readonly attribute CategoryClass category_ref;
         readonly attribute CategoryMapClass category_map_ref;
         readonly attribute CategoryMapObjectClass category_map_object_ref;
         readonly attribute CategoryMapObjectEntryClass category_map_object_entry_ref;
         readonly attribute CategoryMapTableClass category_map_table_ref;
         readonly attribute CategoryMatrixClass category_matrix_ref;
         readonly attribute CategoryMatrixEntryClass category_matrix_entry_ref;
         readonly attribute CategoryMatrixObjectClass category_matrix_object_ref;
         readonly attribute CategoryMatrixTableClass category_matrix_table_ref;
         readonly attribute CategoryTaxonomyClass category_taxonomy_ref;
         readonly attribute PhysicalDataRefSource physical_data_ref_source_ref;
         readonly attribute LogicalAttrHasCategoricalProperties logical_attr_has_categorical_properties_ref;
         readonly attribute LogicalAttrHasNumericalProperties logical_attr_has_numerical_properties_ref;
         readonly attribute CategoricalPropertiesRefTaxonomy categorical_properties_ref_taxonomy_ref;
         readonly attribute CategoricalPropertiesHasCategories categorical_properties_has_categories_ref;
         readonly attribute AssignmentRefLogicalAttribute assignment_ref_logical_attribute_ref;
         readonly attribute AssignmentRefOrderIdAttribute assignment_ref_order_id_attribute_ref;
         readonly attribute PivotRefSetIdAttribute pivot_ref_set_id_attribute_ref;
         readonly attribute PivotRefNameAttribute pivot_ref_name_attribute_ref;
         readonly attribute PivotRefValueAttribute pivot_ref_value_attribute_ref;
         readonly attribute SetAssignmentRefSetIdAttr set_assignment_ref_set_id_attr_ref;
         readonly attribute SetAssignmentRefMemberAttr set_assignment_ref_member_attr_ref;
         readonly attribute ReversePivotRefAttribute reverse_pivot_ref_attribute_ref;
         readonly attribute DirectAssignmentRefAttribute direct_assignment_ref_attribute_ref;
         readonly attribute UsageRefAttribute usage_ref_attribute_ref;
         readonly attribute AssignmentSetHasAssignment assignment_set_has_assignment_ref;
         readonly attribute CategoryMapObjectHasEntry category_map_object_has_entry_ref;
         readonly attribute TaxonomyHasCategoryMap taxonomy_has_category_map_ref;
         readonly attribute MapEntryRefChildCategory map_entry_ref_child_category_ref;
         readonly attribute MatrixEntryRefColumnIndex matrix_entry_ref_column_index_ref;
         readonly attribute MatrixObjectHasEntry matrix_object_has_entry_ref;
         readonly attribute MapEntryRefParentCategory map_entry_ref_parent_category_ref;
         readonly attribute TaxonomyRefRootCategory taxonomy_ref_root_category_ref;
         readonly attribute MatrixEntryRefRowIndex matrix_entry_ref_row_index_ref;
         readonly attribute MatrixTableRefSource matrix_table_ref_source_ref;
         readonly attribute MapTableRefChildAttribute map_table_ref_child_attribute_ref;
         readonly attribute CategoryMapRefClass category_map_ref_class_ref;
         readonly attribute MatrixTableRefColumnAttr matrix_table_ref_column_attr_ref;
         readonly attribute MapTableRefGraphIdAttribute map_table_ref_graph_id_attribute_ref;
         readonly attribute MatrixRefIndexLabels matrix_ref_index_labels_ref;
         readonly attribute MapTableRefParentAttribute map_table_ref_parent_attribute_ref;
         readonly attribute MatrixTableRefRowAttr matrix_table_ref_row_attr_ref;
         readonly attribute MatrixTableRefValueAttr matrix_table_ref_value_attr_ref;
      };
   }; // end of module MiningDataModule

   module MiningFunctionSettingsModule
   {
      interface MiningAlgorithmSettingsClass;
      interface MiningAlgorithmSettings;
      typedef sequence<MiningAlgorithmSettings> MiningAlgorithmSettingsSet;
      interface MiningFunctionSettingsClass;
      interface MiningFunctionSettings;
      typedef sequence<MiningFunctionSettings> MiningFunctionSettingsSet;
      interface MiningFunctionSettingsModulePackage;

      interface MiningAlgorithmSettingsClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningAlgorithmSettingsSet all_of_type_mining_algorithm_settings;
      };

      interface MiningAlgorithmSettings : MiningAlgorithmSettingsClass, CoreModule::ModelElement
      {
      }; // end of interface MiningAlgorithmSettings

      interface MiningFunctionSettingsClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningFunctionSettingsSet all_of_type_mining_function_settings;
      };

      interface MiningFunctionSettings : MiningFunctionSettingsClass, CoreModule::ModelElement
      {
         MiningAlgorithmSettings algorithm_settings ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_algorithm_settings (in MiningAlgorithmSettings new_value)
            raises (Reflective::MofError);
         void unset_algorithm_settings ()
            raises (Reflective::MofError);
         long desired_execution_time_in_minutes ()
            raises (Reflective::MofError);
         void set_desired_execution_time_in_minutes (in long new_value)
            raises (Reflective::MofError);
         MiningDataModule::AttributeUsageSet attribute_usage_set ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_attribute_usage_set (in MiningDataModule::AttributeUsageSet new_value)
            raises (Reflective::MofError);
         void unset_attribute_usage_set ()
            raises (Reflective::MofError);
         MiningDataModule::LogicalData logical_data ()
            raises (Reflective::MofError);
         void set_logical_data (in MiningDataModule::LogicalData new_value)
            raises (Reflective::MofError);
      }; // end of interface MiningFunctionSettings

      struct SettingsRefAlgorithmSettingsLink
      {
         MiningAlgorithmSettings algorithm_settings;
         MiningFunctionSettings settings;
      };
      typedef sequence<SettingsRefAlgorithmSettingsLink> SettingsRefAlgorithmSettingsLinkSet;

      interface SettingsRefAlgorithmSettings : Reflective::RefAssociation
      {
         SettingsRefAlgorithmSettingsLinkSet all_settings_ref_algorithm_settings_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningAlgorithmSettings algorithm_settings,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         MiningAlgorithmSettings algorithm_settings (in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         void add (
            in MiningAlgorithmSettings algorithm_settings,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         void modify_algorithm_settings (
            in MiningAlgorithmSettings algorithm_settings,
            in MiningFunctionSettings settings,
            in MiningAlgorithmSettings new_algorithm_settings)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningAlgorithmSettings algorithm_settings,
            in MiningFunctionSettings settings)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SettingsRefAlgorithmSettings

      struct SettingsHasAttributeUsageSetLink
      {
         MiningDataModule::AttributeUsageSet attribute_usage_set;
         MiningFunctionSettings settings;
      };
      typedef sequence<SettingsHasAttributeUsageSetLink> SettingsHasAttributeUsageSetLinkSet;

      interface SettingsHasAttributeUsageSet : Reflective::RefAssociation
      {
         SettingsHasAttributeUsageSetLinkSet all_settings_has_attribute_usage_set_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeUsageSet attribute_usage_set,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         MiningDataModule::AttributeUsageSet attribute_usage_set (in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         MiningFunctionSettings settings (in MiningDataModule::AttributeUsageSet attribute_usage_set)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeUsageSet attribute_usage_set,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         void modify_attribute_usage_set (
            in MiningDataModule::AttributeUsageSet attribute_usage_set,
            in MiningFunctionSettings settings,
            in MiningDataModule::AttributeUsageSet new_attribute_usage_set)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_settings (
            in MiningDataModule::AttributeUsageSet attribute_usage_set,
            in MiningFunctionSettings settings,
            in MiningFunctionSettings new_settings)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeUsageSet attribute_usage_set,
            in MiningFunctionSettings settings)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SettingsHasAttributeUsageSet

      struct SettingsRefLogicalDataLink
      {
         MiningDataModule::LogicalData logical_data;
         MiningFunctionSettings settings;
      };
      typedef sequence<SettingsRefLogicalDataLink> SettingsRefLogicalDataLinkSet;

      interface SettingsRefLogicalData : Reflective::RefAssociation
      {
         SettingsRefLogicalDataLinkSet all_settings_ref_logical_data_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::LogicalData logical_data,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         MiningDataModule::LogicalData logical_data (in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::LogicalData logical_data,
            in MiningFunctionSettings settings)
            raises (Reflective::MofError);
         void modify_logical_data (
            in MiningDataModule::LogicalData logical_data,
            in MiningFunctionSettings settings,
            in MiningDataModule::LogicalData new_logical_data)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::LogicalData logical_data,
            in MiningFunctionSettings settings)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SettingsRefLogicalData

      interface MiningFunctionSettingsModulePackage : Reflective::RefPackage
      {
         readonly attribute MiningAlgorithmSettingsClass mining_algorithm_settings_ref;
         readonly attribute MiningFunctionSettingsClass mining_function_settings_ref;
         readonly attribute SettingsRefAlgorithmSettings settings_ref_algorithm_settings_ref;
         readonly attribute SettingsHasAttributeUsageSet settings_has_attribute_usage_set_ref;
         readonly attribute SettingsRefLogicalData settings_ref_logical_data_ref;
      };
   }; // end of module MiningFunctionSettingsModule

   module MiningModelModule
   {
      interface MiningModelClass;
      interface MiningModel;
      typedef sequence<MiningModel> MiningModelSet;
      interface ModelSignatureClass;
      interface ModelSignature;
      typedef sequence<ModelSignature> ModelSignatureSet;
      interface SignatureAttributeClass;
      interface SignatureAttribute;
      typedef sequence<SignatureAttribute> SignatureAttributeSet;
      interface MiningModelModulePackage;
      enum MiningFunction {classification, regression, clustering, associationRules, attributeImportance, sequenceAnalysis};

      interface MiningModelClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningModelSet all_of_type_mining_model;
         readonly attribute MiningModelSet all_of_class_mining_model;
         MiningModel create_mining_model (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in MiningFunction function,
            in string algorithm_name,
            in any key_value)
            raises (Reflective::MofError);
      };

      interface MiningModel : MiningModelClass, CoreModule::ModelElement
      {
         MiningFunction function ()
            raises (Reflective::MofError);
         void set_function (in MiningFunction new_value)
            raises (Reflective::MofError);
         string algorithm_name ()
            raises (Reflective::MofError);
         void set_algorithm_name (in string new_value)
            raises (Reflective::MofError);
         MiningFunctionSettingsModule::MiningFunctionSettings settings ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_settings (in MiningFunctionSettingsModule::MiningFunctionSettings new_value)
            raises (Reflective::MofError);
         void unset_settings ()
            raises (Reflective::MofError);
         ModelSignature model_signature ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_model_signature (in ModelSignature new_value)
            raises (Reflective::MofError);
         void unset_model_signature ()
            raises (Reflective::MofError);
         CoreModule::Class model_location ()
            raises (Reflective::MofError);
         void set_model_location (in CoreModule::Class new_value)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute key_attribute ()
            raises (Reflective::MofError);
         void set_key_attribute (in CoreModule::UmlAttribute new_value)
            raises (Reflective::MofError);
         any key_value ()
            raises (Reflective::MofError);
         void set_key_value (in any new_value)
            raises (Reflective::MofError);
      }; // end of interface MiningModel

      interface ModelSignatureClass : CoreModule::ClassClass
      {
         readonly attribute ModelSignatureSet all_of_type_model_signature;
         readonly attribute ModelSignatureSet all_of_class_model_signature;
         ModelSignature create_model_signature (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in boolean is_abstract)
            raises (Reflective::MofError);
      };

      interface ModelSignature : ModelSignatureClass, CoreModule::Class
      {
      }; // end of interface ModelSignature

      interface SignatureAttributeClass : MiningDataModule::MiningAttributeClass
      {
         readonly attribute SignatureAttributeSet all_of_type_signature_attribute;
         readonly attribute SignatureAttributeSet all_of_class_signature_attribute;
         SignatureAttribute create_signature_attribute (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type,
            in MiningDataModule::UsageOption usage_option)
            raises (Reflective::MofError);
      };

      interface SignatureAttribute : SignatureAttributeClass, MiningDataModule::MiningAttribute
      {
         MiningDataModule::UsageOption usage_option ()
            raises (Reflective::MofError);
         void set_usage_option (in MiningDataModule::UsageOption new_value)
            raises (Reflective::MofError);
      }; // end of interface SignatureAttribute

      struct ModelRefSettingsLink
      {
         MiningFunctionSettingsModule::MiningFunctionSettings settings;
         MiningModel model;
      };
      typedef sequence<ModelRefSettingsLink> ModelRefSettingsLinkSet;

      interface ModelRefSettings : Reflective::RefAssociation
      {
         ModelRefSettingsLinkSet all_model_ref_settings_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningFunctionSettingsModule::MiningFunctionSettings settings,
            in MiningModel model)
            raises (Reflective::MofError);
         MiningFunctionSettingsModule::MiningFunctionSettings settings (in MiningModel model)
            raises (Reflective::MofError);
         void add (
            in MiningFunctionSettingsModule::MiningFunctionSettings settings,
            in MiningModel model)
            raises (Reflective::MofError);
         void modify_settings (
            in MiningFunctionSettingsModule::MiningFunctionSettings settings,
            in MiningModel model,
            in MiningFunctionSettingsModule::MiningFunctionSettings new_settings)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningFunctionSettingsModule::MiningFunctionSettings settings,
            in MiningModel model)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ModelRefSettings

      struct ModelHasSignatureLink
      {
         ModelSignature model_signature;
         MiningModel model;
      };
      typedef sequence<ModelHasSignatureLink> ModelHasSignatureLinkSet;

      interface ModelHasSignature : Reflective::RefAssociation
      {
         ModelHasSignatureLinkSet all_model_has_signature_links()
            raises (Reflective::MofError);
         boolean exists (
            in ModelSignature model_signature,
            in MiningModel model)
            raises (Reflective::MofError);
         ModelSignature model_signature (in MiningModel model)
            raises (Reflective::MofError);
         MiningModel model (in ModelSignature model_signature)
            raises (Reflective::MofError);
         void add (
            in ModelSignature model_signature,
            in MiningModel model)
            raises (Reflective::MofError);
         void modify_model_signature (
            in ModelSignature model_signature,
            in MiningModel model,
            in ModelSignature new_model_signature)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_model (
            in ModelSignature model_signature,
            in MiningModel model,
            in MiningModel new_model)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in ModelSignature model_signature,
            in MiningModel model)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ModelHasSignature

      struct ModelRefLocationLink
      {
         CoreModule::Class model_location;
         MiningModel model;
      };
      typedef sequence<ModelRefLocationLink> ModelRefLocationLinkSet;

      interface ModelRefLocation : Reflective::RefAssociation
      {
         ModelRefLocationLinkSet all_model_ref_location_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::Class model_location,
            in MiningModel model)
            raises (Reflective::MofError);
         CoreModule::Class model_location (in MiningModel model)
            raises (Reflective::MofError);
         void add (
            in CoreModule::Class model_location,
            in MiningModel model)
            raises (Reflective::MofError);
         void modify_model_location (
            in CoreModule::Class model_location,
            in MiningModel model,
            in CoreModule::Class new_model_location)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::Class model_location,
            in MiningModel model)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ModelRefLocation

      struct ModelRefKeyAttributeLink
      {
         CoreModule::UmlAttribute key_attribute;
         MiningModel model;
      };
      typedef sequence<ModelRefKeyAttributeLink> ModelRefKeyAttributeLinkSet;

      interface ModelRefKeyAttribute : Reflective::RefAssociation
      {
         ModelRefKeyAttributeLinkSet all_model_ref_key_attribute_links()
            raises (Reflective::MofError);
         boolean exists (
            in CoreModule::UmlAttribute key_attribute,
            in MiningModel model)
            raises (Reflective::MofError);
         CoreModule::UmlAttribute key_attribute (in MiningModel model)
            raises (Reflective::MofError);
         void add (
            in CoreModule::UmlAttribute key_attribute,
            in MiningModel model)
            raises (Reflective::MofError);
         void modify_key_attribute (
            in CoreModule::UmlAttribute key_attribute,
            in MiningModel model,
            in CoreModule::UmlAttribute new_key_attribute)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in CoreModule::UmlAttribute key_attribute,
            in MiningModel model)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ModelRefKeyAttribute

      interface MiningModelModulePackage : Reflective::RefPackage
      {
         readonly attribute MiningModelClass mining_model_ref;
         readonly attribute ModelSignatureClass model_signature_ref;
         readonly attribute SignatureAttributeClass signature_attribute_ref;
         readonly attribute ModelRefSettings model_ref_settings_ref;
         readonly attribute ModelHasSignature model_has_signature_ref;
         readonly attribute ModelRefLocation model_ref_location_ref;
         readonly attribute ModelRefKeyAttribute model_ref_key_attribute_ref;
      };
   }; // end of module MiningModelModule

   module MiningResultModule
   {
      interface MiningResultClass;
      interface MiningResult;
      typedef sequence<MiningResult> MiningResultSet;
      interface MiningResultModulePackage;

      interface MiningResultClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningResultSet all_of_type_mining_result;
      };

      interface MiningResult : MiningResultClass, CoreModule::ModelElement
      {
      }; // end of interface MiningResult

      interface MiningResultModulePackage : Reflective::RefPackage
      {
         readonly attribute MiningResultClass mining_result_ref;
      };
   }; // end of module MiningResultModule

   module MiningTaskModule
   {
      interface ApplyOutputItemClass;
      interface ApplyOutputItem;
      typedef sequence<ApplyOutputItem> ApplyOutputItemSet;
      typedef sequence<ApplyOutputItem> ApplyOutputItemUList;
      interface ApplyContentItemClass;
      interface ApplyContentItem;
      typedef sequence<ApplyContentItem> ApplyContentItemSet;
      interface ApplyProbabilityItemClass;
      interface ApplyProbabilityItem;
      typedef sequence<ApplyProbabilityItem> ApplyProbabilityItemSet;
      interface ApplyRuleIdItemClass;
      interface ApplyRuleIdItem;
      typedef sequence<ApplyRuleIdItem> ApplyRuleIdItemSet;
      interface ApplyScoreItemClass;
      interface ApplyScoreItem;
      typedef sequence<ApplyScoreItem> ApplyScoreItemSet;
      interface ApplySourceItemClass;
      interface ApplySourceItem;
      typedef sequence<ApplySourceItem> ApplySourceItemSet;
      interface MiningApplyOutputClass;
      interface MiningApplyOutput;
      typedef sequence<MiningApplyOutput> MiningApplyOutputSet;
      interface MiningTaskClass;
      interface MiningTask;
      typedef sequence<MiningTask> MiningTaskSet;
      interface MiningApplyTaskClass;
      interface MiningApplyTask;
      typedef sequence<MiningApplyTask> MiningApplyTaskSet;
      interface MiningBuildTaskClass;
      interface MiningBuildTask;
      typedef sequence<MiningBuildTask> MiningBuildTaskSet;
      interface MiningTransformationClass;
      interface MiningTransformation;
      typedef sequence<MiningTransformation> MiningTransformationSet;
      interface MiningTaskModulePackage;
      enum ApplyOutputOption {appendToExisting, createNew};

      interface ApplyOutputItemClass : MiningDataModule::MiningAttributeClass
      {
         readonly attribute ApplyOutputItemSet all_of_type_apply_output_item;
         readonly attribute ApplyOutputItemSet all_of_class_apply_output_item;
         ApplyOutputItem create_apply_output_item (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type)
            raises (Reflective::MofError);
      };

      interface ApplyOutputItem : ApplyOutputItemClass, MiningDataModule::MiningAttribute
      {
      }; // end of interface ApplyOutputItem

      interface ApplyContentItemClass : ApplyOutputItemClass
      {
         readonly attribute ApplyContentItemSet all_of_type_apply_content_item;
      };

      interface ApplyContentItem : ApplyContentItemClass, ApplyOutputItem
      {
         long top_nth_index ()
            raises (Reflective::MofError);
         void set_top_nth_index (in long new_value)
            raises (Reflective::MofError);
      }; // end of interface ApplyContentItem

      interface ApplyProbabilityItemClass : ApplyContentItemClass
      {
         readonly attribute ApplyProbabilityItemSet all_of_type_apply_probability_item;
         readonly attribute ApplyProbabilityItemSet all_of_class_apply_probability_item;
         ApplyProbabilityItem create_apply_probability_item (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type,
            in long top_nth_index)
            raises (Reflective::MofError);
      };

      interface ApplyProbabilityItem : ApplyProbabilityItemClass, ApplyContentItem
      {
      }; // end of interface ApplyProbabilityItem

      interface ApplyRuleIdItemClass : ApplyContentItemClass
      {
         readonly attribute ApplyRuleIdItemSet all_of_type_apply_rule_id_item;
         readonly attribute ApplyRuleIdItemSet all_of_class_apply_rule_id_item;
         ApplyRuleIdItem create_apply_rule_id_item (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type,
            in long top_nth_index)
            raises (Reflective::MofError);
      };

      interface ApplyRuleIdItem : ApplyRuleIdItemClass, ApplyContentItem
      {
      }; // end of interface ApplyRuleIdItem

      interface ApplyScoreItemClass : ApplyContentItemClass
      {
         readonly attribute ApplyScoreItemSet all_of_type_apply_score_item;
         readonly attribute ApplyScoreItemSet all_of_class_apply_score_item;
         ApplyScoreItem create_apply_score_item (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type,
            in long top_nth_index)
            raises (Reflective::MofError);
      };

      interface ApplyScoreItem : ApplyScoreItemClass, ApplyContentItem
      {
      }; // end of interface ApplyScoreItem

      interface ApplySourceItemClass : ApplyOutputItemClass
      {
         readonly attribute ApplySourceItemSet all_of_type_apply_source_item;
         readonly attribute ApplySourceItemSet all_of_class_apply_source_item;
         ApplySourceItem create_apply_source_item (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ScopeKind owner_scope,
            in CoreModule::ChangeableKind changeability,
            in CoreModule::Multiplicity multiplicity,
            in CoreModule::OrderingKind ordering,
            in CoreModule::ScopeKind target_scope,
            in CoreModule::Expression initial_value,
            in string display_name,
            in MiningDataModule::AttributeType attribute_type)
            raises (Reflective::MofError);
      };

      interface ApplySourceItem : ApplySourceItemClass, ApplyOutputItem
      {
      }; // end of interface ApplySourceItem

      interface MiningApplyOutputClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningApplyOutputSet all_of_type_mining_apply_output;
         readonly attribute MiningApplyOutputSet all_of_class_mining_apply_output;
         MiningApplyOutput create_mining_apply_output (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface MiningApplyOutput : MiningApplyOutputClass, CoreModule::ModelElement
      {
         ApplyOutputItemUList item ()
            raises (Reflective::MofError);
         void set_item (in ApplyOutputItemUList new_value)
            raises (Reflective::MofError);
         void add_item (in ApplyOutputItem new_element)
            raises (Reflective::MofError);
         void add_item_before (
            in ApplyOutputItem new_element,
            in ApplyOutputItem before_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_item (
            in ApplyOutputItem old_element,
            in ApplyOutputItem new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_item (in ApplyOutputItem old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface MiningApplyOutput

      interface MiningTaskClass : CoreModule::ModelElementClass
      {
         readonly attribute MiningTaskSet all_of_type_mining_task;
      };

      interface MiningTask : MiningTaskClass, CoreModule::ModelElement
      {
         MiningDataModule::PhysicalData input_data ()
            raises (Reflective::MofError);
         void set_input_data (in MiningDataModule::PhysicalData new_value)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet model_assignment ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_model_assignment (in MiningDataModule::AttributeAssignmentSet new_value)
            raises (Reflective::MofError);
         void unset_model_assignment ()
            raises (Reflective::MofError);
         MiningModelModule::MiningModel input_model ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_input_model (in MiningModelModule::MiningModel new_value)
            raises (Reflective::MofError);
         void unset_input_model ()
            raises (Reflective::MofError);
      }; // end of interface MiningTask

      interface MiningApplyTaskClass : MiningTaskClass
      {
         readonly attribute MiningApplyTaskSet all_of_type_mining_apply_task;
         readonly attribute MiningApplyTaskSet all_of_class_mining_apply_task;
         MiningApplyTask create_mining_apply_task (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in ApplyOutputOption output_option)
            raises (Reflective::MofError);
      };

      interface MiningApplyTask : MiningApplyTaskClass, MiningTask
      {
         MiningApplyOutput apply_output ()
            raises (Reflective::MofError);
         void set_apply_output (in MiningApplyOutput new_value)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet output_assignment ()
            raises (Reflective::MofError);
         void set_output_assignment (in MiningDataModule::AttributeAssignmentSet new_value)
            raises (Reflective::MofError);
         ApplyOutputOption output_option ()
            raises (Reflective::MofError);
         void set_output_option (in ApplyOutputOption new_value)
            raises (Reflective::MofError);
      }; // end of interface MiningApplyTask

      interface MiningBuildTaskClass : MiningTaskClass
      {
         readonly attribute MiningBuildTaskSet all_of_type_mining_build_task;
         readonly attribute MiningBuildTaskSet all_of_class_mining_build_task;
         MiningBuildTask create_mining_build_task (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface MiningBuildTask : MiningBuildTaskClass, MiningTask
      {
         MiningFunctionSettingsModule::MiningFunctionSettings mining_settings ()
            raises (Reflective::MofError);
         void set_mining_settings (in MiningFunctionSettingsModule::MiningFunctionSettings new_value)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet settings_assignment ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_settings_assignment (in MiningDataModule::AttributeAssignmentSet new_value)
            raises (Reflective::MofError);
         void unset_settings_assignment ()
            raises (Reflective::MofError);
         MiningDataModule::PhysicalData validation_data ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_validation_data (in MiningDataModule::PhysicalData new_value)
            raises (Reflective::MofError);
         void unset_validation_data ()
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet validation_assignment ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_validation_assignment (in MiningDataModule::AttributeAssignmentSet new_value)
            raises (Reflective::MofError);
         void unset_validation_assignment ()
            raises (Reflective::MofError);
         MiningModelModule::MiningModel result_model ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_result_model (in MiningModelModule::MiningModel new_value)
            raises (Reflective::MofError);
         void unset_result_model ()
            raises (Reflective::MofError);
      }; // end of interface MiningBuildTask

      interface MiningTransformationClass : TransformationModule::TransformationClass
      {
         readonly attribute MiningTransformationSet all_of_type_mining_transformation;
         readonly attribute MiningTransformationSet all_of_class_mining_transformation;
         MiningTransformation create_mining_transformation (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility,
            in CoreModule::ProcedureExpression function,
            in string function_description,
            in boolean is_primary)
            raises (Reflective::MofError);
      };

      interface MiningTransformation : MiningTransformationClass, TransformationModule::Transformation
      {
         MiningTask procedure ()
            raises (Reflective::MofError);
         void set_procedure (in MiningTask new_value)
            raises (Reflective::MofError);
      }; // end of interface MiningTransformation

      struct TransformationRefMiningTaskLink
      {
         MiningTask procedure;
         MiningTransformation transformation;
      };
      typedef sequence<TransformationRefMiningTaskLink> TransformationRefMiningTaskLinkSet;

      interface TransformationRefMiningTask : Reflective::RefAssociation
      {
         TransformationRefMiningTaskLinkSet all_transformation_ref_mining_task_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningTask procedure,
            in MiningTransformation transformation)
            raises (Reflective::MofError);
         MiningTask procedure (in MiningTransformation transformation)
            raises (Reflective::MofError);
         void add (
            in MiningTask procedure,
            in MiningTransformation transformation)
            raises (Reflective::MofError);
         void modify_procedure (
            in MiningTask procedure,
            in MiningTransformation transformation,
            in MiningTask new_procedure)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningTask procedure,
            in MiningTransformation transformation)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TransformationRefMiningTask

      struct TaskRefInputModelLink
      {
         MiningModelModule::MiningModel input_model;
         MiningTask mining_task;
      };
      typedef sequence<TaskRefInputModelLink> TaskRefInputModelLinkSet;

      interface TaskRefInputModel : Reflective::RefAssociation
      {
         TaskRefInputModelLinkSet all_task_ref_input_model_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningModelModule::MiningModel input_model,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         MiningModelModule::MiningModel input_model (in MiningTask mining_task)
            raises (Reflective::MofError);
         void add (
            in MiningModelModule::MiningModel input_model,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         void modify_input_model (
            in MiningModelModule::MiningModel input_model,
            in MiningTask mining_task,
            in MiningModelModule::MiningModel new_input_model)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningModelModule::MiningModel input_model,
            in MiningTask mining_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TaskRefInputModel

      struct TaskRefPhysicalDataLink
      {
         MiningDataModule::PhysicalData input_data;
         MiningTask mining_task;
      };
      typedef sequence<TaskRefPhysicalDataLink> TaskRefPhysicalDataLinkSet;

      interface TaskRefPhysicalData : Reflective::RefAssociation
      {
         TaskRefPhysicalDataLinkSet all_task_ref_physical_data_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::PhysicalData input_data,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         MiningDataModule::PhysicalData input_data (in MiningTask mining_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::PhysicalData input_data,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         void modify_input_data (
            in MiningDataModule::PhysicalData input_data,
            in MiningTask mining_task,
            in MiningDataModule::PhysicalData new_input_data)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::PhysicalData input_data,
            in MiningTask mining_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TaskRefPhysicalData

      struct TaskRefAttrAssignmentSetLink
      {
         MiningDataModule::AttributeAssignmentSet model_assignment;
         MiningTask mining_task;
      };
      typedef sequence<TaskRefAttrAssignmentSetLink> TaskRefAttrAssignmentSetLinkSet;

      interface TaskRefAttrAssignmentSet : Reflective::RefAssociation
      {
         TaskRefAttrAssignmentSetLinkSet all_task_ref_attr_assignment_set_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeAssignmentSet model_assignment,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet model_assignment (in MiningTask mining_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeAssignmentSet model_assignment,
            in MiningTask mining_task)
            raises (Reflective::MofError);
         void modify_model_assignment (
            in MiningDataModule::AttributeAssignmentSet model_assignment,
            in MiningTask mining_task,
            in MiningDataModule::AttributeAssignmentSet new_model_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeAssignmentSet model_assignment,
            in MiningTask mining_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface TaskRefAttrAssignmentSet

      struct ApplyTaskRefOutputAssignmentLink
      {
         MiningDataModule::AttributeAssignmentSet output_assignment;
         MiningApplyTask apply_task;
      };
      typedef sequence<ApplyTaskRefOutputAssignmentLink> ApplyTaskRefOutputAssignmentLinkSet;

      interface ApplyTaskRefOutputAssignment : Reflective::RefAssociation
      {
         ApplyTaskRefOutputAssignmentLinkSet all_apply_task_ref_output_assignment_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeAssignmentSet output_assignment,
            in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet output_assignment (in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeAssignmentSet output_assignment,
            in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         void modify_output_assignment (
            in MiningDataModule::AttributeAssignmentSet output_assignment,
            in MiningApplyTask apply_task,
            in MiningDataModule::AttributeAssignmentSet new_output_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeAssignmentSet output_assignment,
            in MiningApplyTask apply_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ApplyTaskRefOutputAssignment

      struct ApplyTaskRefOutputSpecLink
      {
         MiningApplyOutput apply_output;
         MiningApplyTask apply_task;
      };
      typedef sequence<ApplyTaskRefOutputSpecLink> ApplyTaskRefOutputSpecLinkSet;

      interface ApplyTaskRefOutputSpec : Reflective::RefAssociation
      {
         ApplyTaskRefOutputSpecLinkSet all_apply_task_ref_output_spec_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningApplyOutput apply_output,
            in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         MiningApplyOutput apply_output (in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         void add (
            in MiningApplyOutput apply_output,
            in MiningApplyTask apply_task)
            raises (Reflective::MofError);
         void modify_apply_output (
            in MiningApplyOutput apply_output,
            in MiningApplyTask apply_task,
            in MiningApplyOutput new_apply_output)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningApplyOutput apply_output,
            in MiningApplyTask apply_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ApplyTaskRefOutputSpec

      struct BuildTaskProducesModelLink
      {
         MiningModelModule::MiningModel result_model;
         MiningBuildTask build_task;
      };
      typedef sequence<BuildTaskProducesModelLink> BuildTaskProducesModelLinkSet;

      interface BuildTaskProducesModel : Reflective::RefAssociation
      {
         BuildTaskProducesModelLinkSet all_build_task_produces_model_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningModelModule::MiningModel result_model,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         MiningModelModule::MiningModel result_model (in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void add (
            in MiningModelModule::MiningModel result_model,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void modify_result_model (
            in MiningModelModule::MiningModel result_model,
            in MiningBuildTask build_task,
            in MiningModelModule::MiningModel new_result_model)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningModelModule::MiningModel result_model,
            in MiningBuildTask build_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface BuildTaskProducesModel

      struct BuildTaskRefSettingsLink
      {
         MiningFunctionSettingsModule::MiningFunctionSettings mining_settings;
         MiningBuildTask build_task;
      };
      typedef sequence<BuildTaskRefSettingsLink> BuildTaskRefSettingsLinkSet;

      interface BuildTaskRefSettings : Reflective::RefAssociation
      {
         BuildTaskRefSettingsLinkSet all_build_task_ref_settings_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_settings,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         MiningFunctionSettingsModule::MiningFunctionSettings mining_settings (in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void add (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_settings,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void modify_mining_settings (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_settings,
            in MiningBuildTask build_task,
            in MiningFunctionSettingsModule::MiningFunctionSettings new_mining_settings)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_settings,
            in MiningBuildTask build_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface BuildTaskRefSettings

      struct BuildTaskRefValidationAssignmentLink
      {
         MiningDataModule::AttributeAssignmentSet validation_assignment;
         MiningBuildTask build_task;
      };
      typedef sequence<BuildTaskRefValidationAssignmentLink> BuildTaskRefValidationAssignmentLinkSet;

      interface BuildTaskRefValidationAssignment : Reflective::RefAssociation
      {
         BuildTaskRefValidationAssignmentLinkSet all_build_task_ref_validation_assignment_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeAssignmentSet validation_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet validation_assignment (in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeAssignmentSet validation_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void modify_validation_assignment (
            in MiningDataModule::AttributeAssignmentSet validation_assignment,
            in MiningBuildTask build_task,
            in MiningDataModule::AttributeAssignmentSet new_validation_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeAssignmentSet validation_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface BuildTaskRefValidationAssignment

      struct BuildTaskRefInputAssignmentLink
      {
         MiningDataModule::AttributeAssignmentSet settings_assignment;
         MiningBuildTask build_task;
      };
      typedef sequence<BuildTaskRefInputAssignmentLink> BuildTaskRefInputAssignmentLinkSet;

      interface BuildTaskRefInputAssignment : Reflective::RefAssociation
      {
         BuildTaskRefInputAssignmentLinkSet all_build_task_ref_input_assignment_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeAssignmentSet settings_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSet settings_assignment (in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeAssignmentSet settings_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void modify_settings_assignment (
            in MiningDataModule::AttributeAssignmentSet settings_assignment,
            in MiningBuildTask build_task,
            in MiningDataModule::AttributeAssignmentSet new_settings_assignment)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeAssignmentSet settings_assignment,
            in MiningBuildTask build_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface BuildTaskRefInputAssignment

      struct BuildTaskRefValidationDataLink
      {
         MiningDataModule::PhysicalData validation_data;
         MiningBuildTask build_task;
      };
      typedef sequence<BuildTaskRefValidationDataLink> BuildTaskRefValidationDataLinkSet;

      interface BuildTaskRefValidationData : Reflective::RefAssociation
      {
         BuildTaskRefValidationDataLinkSet all_build_task_ref_validation_data_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::PhysicalData validation_data,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         MiningDataModule::PhysicalData validation_data (in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::PhysicalData validation_data,
            in MiningBuildTask build_task)
            raises (Reflective::MofError);
         void modify_validation_data (
            in MiningDataModule::PhysicalData validation_data,
            in MiningBuildTask build_task,
            in MiningDataModule::PhysicalData new_validation_data)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::PhysicalData validation_data,
            in MiningBuildTask build_task)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface BuildTaskRefValidationData

      struct ApplyOutputHasContentItemsLink
      {
         ApplyOutputItem item;
         MiningApplyOutput apply_output;
      };
      typedef sequence<ApplyOutputHasContentItemsLink> ApplyOutputHasContentItemsLinkSet;

      interface ApplyOutputHasContentItems : Reflective::RefAssociation
      {
         ApplyOutputHasContentItemsLinkSet all_apply_output_has_content_items_links()
            raises (Reflective::MofError);
         boolean exists (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output)
            raises (Reflective::MofError);
         ApplyOutputItemUList item (in MiningApplyOutput apply_output)
            raises (Reflective::MofError);
         MiningApplyOutput apply_output (in ApplyOutputItem item)
            raises (Reflective::MofError);
         void add (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output)
            raises (Reflective::MofError);
         void add_before_item (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output,
            in ApplyOutputItem before)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_item (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output,
            in ApplyOutputItem new_item)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_apply_output (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output,
            in MiningApplyOutput new_apply_output)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in ApplyOutputItem item,
            in MiningApplyOutput apply_output)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface ApplyOutputHasContentItems

      interface MiningTaskModulePackage : Reflective::RefPackage
      {
         readonly attribute ApplyOutputItemClass apply_output_item_ref;
         readonly attribute ApplyContentItemClass apply_content_item_ref;
         readonly attribute ApplyProbabilityItemClass apply_probability_item_ref;
         readonly attribute ApplyRuleIdItemClass apply_rule_id_item_ref;
         readonly attribute ApplyScoreItemClass apply_score_item_ref;
         readonly attribute ApplySourceItemClass apply_source_item_ref;
         readonly attribute MiningApplyOutputClass mining_apply_output_ref;
         readonly attribute MiningTaskClass mining_task_ref;
         readonly attribute MiningApplyTaskClass mining_apply_task_ref;
         readonly attribute MiningBuildTaskClass mining_build_task_ref;
         readonly attribute MiningTransformationClass mining_transformation_ref;
         readonly attribute TransformationRefMiningTask transformation_ref_mining_task_ref;
         readonly attribute TaskRefInputModel task_ref_input_model_ref;
         readonly attribute TaskRefPhysicalData task_ref_physical_data_ref;
         readonly attribute TaskRefAttrAssignmentSet task_ref_attr_assignment_set_ref;
         readonly attribute ApplyTaskRefOutputAssignment apply_task_ref_output_assignment_ref;
         readonly attribute ApplyTaskRefOutputSpec apply_task_ref_output_spec_ref;
         readonly attribute BuildTaskProducesModel build_task_produces_model_ref;
         readonly attribute BuildTaskRefSettings build_task_ref_settings_ref;
         readonly attribute BuildTaskRefValidationAssignment build_task_ref_validation_assignment_ref;
         readonly attribute BuildTaskRefInputAssignment build_task_ref_input_assignment_ref;
         readonly attribute BuildTaskRefValidationData build_task_ref_validation_data_ref;
         readonly attribute ApplyOutputHasContentItems apply_output_has_content_items_ref;
      };
   }; // end of module MiningTaskModule

   module EntryPointModule
   {
      interface AuxiliaryObjectClass;
      interface AuxiliaryObject;
      typedef sequence<AuxiliaryObject> AuxiliaryObjectSet;
      interface CatalogClass;
      interface Catalog;
      typedef sequence<Catalog> CatalogSet;
      interface SchemaClass;
      interface Schema;
      typedef sequence<Schema> SchemaSet;
      interface EntryPointModulePackage;

      interface AuxiliaryObjectClass : CoreModule::ModelElementClass
      {
         readonly attribute AuxiliaryObjectSet all_of_type_auxiliary_object;
         readonly attribute AuxiliaryObjectSet all_of_class_auxiliary_object;
         AuxiliaryObject create_auxiliary_object (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface AuxiliaryObject : AuxiliaryObjectClass, CoreModule::ModelElement
      {
         MiningDataModule::AttributeAssignmentSetSet attribute_assignment_set ()
            raises (Reflective::MofError);
         void set_attribute_assignment_set (in MiningDataModule::AttributeAssignmentSetSet new_value)
            raises (Reflective::MofError);
         void unset_attribute_assignment_set ()
            raises (Reflective::MofError);
         void add_attribute_assignment_set (in MiningDataModule::AttributeAssignmentSet new_element)
            raises (Reflective::MofError);
         void modify_attribute_assignment_set (
            in MiningDataModule::AttributeAssignmentSet old_element,
            in MiningDataModule::AttributeAssignmentSet new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_attribute_assignment_set (in MiningDataModule::AttributeAssignmentSet old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AuxiliaryObject

      interface CatalogClass : CoreModule::PackageClass
      {
         readonly attribute CatalogSet all_of_type_catalog;
         readonly attribute CatalogSet all_of_class_catalog;
         Catalog create_catalog (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface Catalog : CatalogClass, CoreModule::Package
      {
         SchemaSet schema ()
            raises (Reflective::MofError);
         void set_schema (in SchemaSet new_value)
            raises (Reflective::MofError);
         void unset_schema ()
            raises (Reflective::MofError);
         void add_schema (in EntryPointModule::Schema new_element)
            raises (Reflective::MofError);
         void modify_schema (
            in EntryPointModule::Schema old_element,
            in EntryPointModule::Schema new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_schema (in EntryPointModule::Schema old_element)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface Catalog

      interface SchemaClass : CoreModule::NamespaceClass
      {
         readonly attribute SchemaSet all_of_type_schema;
         readonly attribute SchemaSet all_of_class_schema;
         Schema create_schema (
            in CoreModule::Name name,
            in CoreModule::VisibilityKind visibility)
            raises (Reflective::MofError);
      };

      interface Schema : SchemaClass, CoreModule::Namespace
      {
         MiningDataModule::LogicalDataSet logical_data ()
            raises (Reflective::MofError);
         void set_logical_data (in MiningDataModule::LogicalDataSet new_value)
            raises (Reflective::MofError);
         void unset_logical_data ()
            raises (Reflective::MofError);
         void add_logical_data (in MiningDataModule::LogicalData new_element)
            raises (Reflective::MofError);
         void modify_logical_data (
            in MiningDataModule::LogicalData old_element,
            in MiningDataModule::LogicalData new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_logical_data (in MiningDataModule::LogicalData old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningDataModule::CategoryMatrixSet category_matrix ()
            raises (Reflective::MofError);
         void set_category_matrix (in MiningDataModule::CategoryMatrixSet new_value)
            raises (Reflective::MofError);
         void unset_category_matrix ()
            raises (Reflective::MofError);
         void add_category_matrix (in MiningDataModule::CategoryMatrix new_element)
            raises (Reflective::MofError);
         void modify_category_matrix (
            in MiningDataModule::CategoryMatrix old_element,
            in MiningDataModule::CategoryMatrix new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_category_matrix (in MiningDataModule::CategoryMatrix old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningModelModule::MiningModelSet mining_model ()
            raises (Reflective::MofError);
         void set_mining_model (in MiningModelModule::MiningModelSet new_value)
            raises (Reflective::MofError);
         void unset_mining_model ()
            raises (Reflective::MofError);
         void add_mining_model (in MiningModelModule::MiningModel new_element)
            raises (Reflective::MofError);
         void modify_mining_model (
            in MiningModelModule::MiningModel old_element,
            in MiningModelModule::MiningModel new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_mining_model (in MiningModelModule::MiningModel old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningFunctionSettingsModule::MiningFunctionSettingsSet mining_function_settings ()
            raises (Reflective::MofError);
         void set_mining_function_settings (in MiningFunctionSettingsModule::MiningFunctionSettingsSet new_value)
            raises (Reflective::MofError);
         void unset_mining_function_settings ()
            raises (Reflective::MofError);
         void add_mining_function_settings (in MiningFunctionSettingsModule::MiningFunctionSettings new_element)
            raises (Reflective::MofError);
         void modify_mining_function_settings (
            in MiningFunctionSettingsModule::MiningFunctionSettings old_element,
            in MiningFunctionSettingsModule::MiningFunctionSettings new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_mining_function_settings (in MiningFunctionSettingsModule::MiningFunctionSettings old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningDataModule::CategoryTaxonomySet taxonomy ()
            raises (Reflective::MofError);
         void set_taxonomy (in MiningDataModule::CategoryTaxonomySet new_value)
            raises (Reflective::MofError);
         void unset_taxonomy ()
            raises (Reflective::MofError);
         void add_taxonomy (in MiningDataModule::CategoryTaxonomy new_element)
            raises (Reflective::MofError);
         void modify_taxonomy (
            in MiningDataModule::CategoryTaxonomy old_element,
            in MiningDataModule::CategoryTaxonomy new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_taxonomy (in MiningDataModule::CategoryTaxonomy old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningTaskModule::MiningTaskSet mining_task ()
            raises (Reflective::MofError);
         void set_mining_task (in MiningTaskModule::MiningTaskSet new_value)
            raises (Reflective::MofError);
         void unset_mining_task ()
            raises (Reflective::MofError);
         void add_mining_task (in MiningTaskModule::MiningTask new_element)
            raises (Reflective::MofError);
         void modify_mining_task (
            in MiningTaskModule::MiningTask old_element,
            in MiningTaskModule::MiningTask new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_mining_task (in MiningTaskModule::MiningTask old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         MiningResultModule::MiningResultSet result ()
            raises (Reflective::MofError);
         void set_result (in MiningResultModule::MiningResultSet new_value)
            raises (Reflective::MofError);
         void unset_result ()
            raises (Reflective::MofError);
         void add_result (in MiningResultModule::MiningResult new_element)
            raises (Reflective::MofError);
         void modify_result (
            in MiningResultModule::MiningResult old_element,
            in MiningResultModule::MiningResult new_element)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove_result (in MiningResultModule::MiningResult old_element)
            raises (Reflective::NotFound, Reflective::MofError);
         AuxiliaryObject aux_objects ()
            raises (Reflective::NotSet, Reflective::MofError);
         void set_aux_objects (in AuxiliaryObject new_value)
            raises (Reflective::MofError);
         void unset_aux_objects ()
            raises (Reflective::MofError);
      }; // end of interface Schema

      struct CatalogHasSchemaLink
      {
         EntryPointModule::Schema schema;
         EntryPointModule::Catalog catalog;
      };
      typedef sequence<CatalogHasSchemaLink> CatalogHasSchemaLinkSet;

      interface CatalogHasSchema : Reflective::RefAssociation
      {
         CatalogHasSchemaLinkSet all_catalog_has_schema_links()
            raises (Reflective::MofError);
         boolean exists (
            in EntryPointModule::Schema schema,
            in EntryPointModule::Catalog catalog)
            raises (Reflective::MofError);
         SchemaSet schema (in EntryPointModule::Catalog catalog)
            raises (Reflective::MofError);
         EntryPointModule::Catalog catalog (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void add (
            in EntryPointModule::Schema schema,
            in EntryPointModule::Catalog catalog)
            raises (Reflective::MofError);
         void modify_schema (
            in EntryPointModule::Schema schema,
            in EntryPointModule::Catalog catalog,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_catalog (
            in EntryPointModule::Schema schema,
            in EntryPointModule::Catalog catalog,
            in EntryPointModule::Catalog new_catalog)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in EntryPointModule::Schema schema,
            in EntryPointModule::Catalog catalog)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface CatalogHasSchema

      struct SchemaHasLogicalDataLink
      {
         MiningDataModule::LogicalData logical_data;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasLogicalDataLink> SchemaHasLogicalDataLinkSet;

      interface SchemaHasLogicalData : Reflective::RefAssociation
      {
         SchemaHasLogicalDataLinkSet all_schema_has_logical_data_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::LogicalData logical_data,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningDataModule::LogicalDataSet logical_data (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningDataModule::LogicalData logical_data)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::LogicalData logical_data,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_logical_data (
            in MiningDataModule::LogicalData logical_data,
            in EntryPointModule::Schema schema,
            in MiningDataModule::LogicalData new_logical_data)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningDataModule::LogicalData logical_data,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::LogicalData logical_data,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasLogicalData

      struct SchemaHasCategoryMatrixLink
      {
         MiningDataModule::CategoryMatrix category_matrix;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasCategoryMatrixLink> SchemaHasCategoryMatrixLinkSet;

      interface SchemaHasCategoryMatrix : Reflective::RefAssociation
      {
         SchemaHasCategoryMatrixLinkSet all_schema_has_category_matrix_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::CategoryMatrix category_matrix,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningDataModule::CategoryMatrixSet category_matrix (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningDataModule::CategoryMatrix category_matrix)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::CategoryMatrix category_matrix,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_category_matrix (
            in MiningDataModule::CategoryMatrix category_matrix,
            in EntryPointModule::Schema schema,
            in MiningDataModule::CategoryMatrix new_category_matrix)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningDataModule::CategoryMatrix category_matrix,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::CategoryMatrix category_matrix,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasCategoryMatrix

      struct SchemaHasAuxObjectsLink
      {
         AuxiliaryObject aux_objects;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasAuxObjectsLink> SchemaHasAuxObjectsLinkSet;

      interface SchemaHasAuxObjects : Reflective::RefAssociation
      {
         SchemaHasAuxObjectsLinkSet all_schema_has_aux_objects_links()
            raises (Reflective::MofError);
         boolean exists (
            in AuxiliaryObject aux_objects,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         AuxiliaryObject aux_objects (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in AuxiliaryObject aux_objects)
            raises (Reflective::MofError);
         void add (
            in AuxiliaryObject aux_objects,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_aux_objects (
            in AuxiliaryObject aux_objects,
            in EntryPointModule::Schema schema,
            in AuxiliaryObject new_aux_objects)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in AuxiliaryObject aux_objects,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in AuxiliaryObject aux_objects,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasAuxObjects

      struct AuxObjectHasAttrAssignmentSetLink
      {
         MiningDataModule::AttributeAssignmentSet attribute_assignment_set;
         AuxiliaryObject auxiliary_object;
      };
      typedef sequence<AuxObjectHasAttrAssignmentSetLink> AuxObjectHasAttrAssignmentSetLinkSet;

      interface AuxObjectHasAttrAssignmentSet : Reflective::RefAssociation
      {
         AuxObjectHasAttrAssignmentSetLinkSet all_aux_object_has_attr_assignment_set_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::AttributeAssignmentSet attribute_assignment_set,
            in AuxiliaryObject auxiliary_object)
            raises (Reflective::MofError);
         MiningDataModule::AttributeAssignmentSetSet attribute_assignment_set (in AuxiliaryObject auxiliary_object)
            raises (Reflective::MofError);
         AuxiliaryObject auxiliary_object (in MiningDataModule::AttributeAssignmentSet attribute_assignment_set)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::AttributeAssignmentSet attribute_assignment_set,
            in AuxiliaryObject auxiliary_object)
            raises (Reflective::MofError);
         void modify_attribute_assignment_set (
            in MiningDataModule::AttributeAssignmentSet attribute_assignment_set,
            in AuxiliaryObject auxiliary_object,
            in MiningDataModule::AttributeAssignmentSet new_attribute_assignment_set)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_auxiliary_object (
            in MiningDataModule::AttributeAssignmentSet attribute_assignment_set,
            in AuxiliaryObject auxiliary_object,
            in AuxiliaryObject new_auxiliary_object)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::AttributeAssignmentSet attribute_assignment_set,
            in AuxiliaryObject auxiliary_object)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface AuxObjectHasAttrAssignmentSet

      struct SchemaHasCategoryTaxonomyLink
      {
         MiningDataModule::CategoryTaxonomy taxonomy;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasCategoryTaxonomyLink> SchemaHasCategoryTaxonomyLinkSet;

      interface SchemaHasCategoryTaxonomy : Reflective::RefAssociation
      {
         SchemaHasCategoryTaxonomyLinkSet all_schema_has_category_taxonomy_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningDataModule::CategoryTaxonomy taxonomy,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningDataModule::CategoryTaxonomySet taxonomy (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningDataModule::CategoryTaxonomy taxonomy)
            raises (Reflective::MofError);
         void add (
            in MiningDataModule::CategoryTaxonomy taxonomy,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_taxonomy (
            in MiningDataModule::CategoryTaxonomy taxonomy,
            in EntryPointModule::Schema schema,
            in MiningDataModule::CategoryTaxonomy new_taxonomy)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningDataModule::CategoryTaxonomy taxonomy,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningDataModule::CategoryTaxonomy taxonomy,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasCategoryTaxonomy

      struct SchemaHasFunctionSettingsLink
      {
         MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasFunctionSettingsLink> SchemaHasFunctionSettingsLinkSet;

      interface SchemaHasFunctionSettings : Reflective::RefAssociation
      {
         SchemaHasFunctionSettingsLinkSet all_schema_has_function_settings_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningFunctionSettingsModule::MiningFunctionSettingsSet mining_function_settings (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings)
            raises (Reflective::MofError);
         void add (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_mining_function_settings (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings,
            in EntryPointModule::Schema schema,
            in MiningFunctionSettingsModule::MiningFunctionSettings new_mining_function_settings)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningFunctionSettingsModule::MiningFunctionSettings mining_function_settings,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasFunctionSettings

      struct SchemaHasMiningModelLink
      {
         MiningModelModule::MiningModel mining_model;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasMiningModelLink> SchemaHasMiningModelLinkSet;

      interface SchemaHasMiningModel : Reflective::RefAssociation
      {
         SchemaHasMiningModelLinkSet all_schema_has_mining_model_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningModelModule::MiningModel mining_model,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningModelModule::MiningModelSet mining_model (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningModelModule::MiningModel mining_model)
            raises (Reflective::MofError);
         void add (
            in MiningModelModule::MiningModel mining_model,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_mining_model (
            in MiningModelModule::MiningModel mining_model,
            in EntryPointModule::Schema schema,
            in MiningModelModule::MiningModel new_mining_model)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningModelModule::MiningModel mining_model,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningModelModule::MiningModel mining_model,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasMiningModel

      struct SchemaHasMiningTaskLink
      {
         MiningTaskModule::MiningTask mining_task;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasMiningTaskLink> SchemaHasMiningTaskLinkSet;

      interface SchemaHasMiningTask : Reflective::RefAssociation
      {
         SchemaHasMiningTaskLinkSet all_schema_has_mining_task_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningTaskModule::MiningTask mining_task,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningTaskModule::MiningTaskSet mining_task (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningTaskModule::MiningTask mining_task)
            raises (Reflective::MofError);
         void add (
            in MiningTaskModule::MiningTask mining_task,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_mining_task (
            in MiningTaskModule::MiningTask mining_task,
            in EntryPointModule::Schema schema,
            in MiningTaskModule::MiningTask new_mining_task)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningTaskModule::MiningTask mining_task,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningTaskModule::MiningTask mining_task,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasMiningTask

      struct SchemaHasMiningResultLink
      {
         MiningResultModule::MiningResult result;
         EntryPointModule::Schema schema;
      };
      typedef sequence<SchemaHasMiningResultLink> SchemaHasMiningResultLinkSet;

      interface SchemaHasMiningResult : Reflective::RefAssociation
      {
         SchemaHasMiningResultLinkSet all_schema_has_mining_result_links()
            raises (Reflective::MofError);
         boolean exists (
            in MiningResultModule::MiningResult result,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         MiningResultModule::MiningResultSet result (in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         EntryPointModule::Schema schema (in MiningResultModule::MiningResult result)
            raises (Reflective::MofError);
         void add (
            in MiningResultModule::MiningResult result,
            in EntryPointModule::Schema schema)
            raises (Reflective::MofError);
         void modify_result (
            in MiningResultModule::MiningResult result,
            in EntryPointModule::Schema schema,
            in MiningResultModule::MiningResult new_result)
            raises (Reflective::NotFound, Reflective::MofError);
         void modify_schema (
            in MiningResultModule::MiningResult result,
            in EntryPointModule::Schema schema,
            in EntryPointModule::Schema new_schema)
            raises (Reflective::NotFound, Reflective::MofError);
         void remove (
            in MiningResultModule::MiningResult result,
            in EntryPointModule::Schema schema)
            raises (Reflective::NotFound, Reflective::MofError);
      }; // end of interface SchemaHasMiningResult

      interface EntryPointModulePackage : Reflective::RefPackage
      {
         readonly attribute AuxiliaryObjectClass auxiliary_object_ref;
         readonly attribute CatalogClass catalog_ref;
         readonly attribute SchemaClass schema_ref;
         readonly attribute CatalogHasSchema catalog_has_schema_ref;
         readonly attribute SchemaHasLogicalData schema_has_logical_data_ref;
         readonly attribute SchemaHasCategoryMatrix schema_has_category_matrix_ref;
         readonly attribute SchemaHasAuxObjects schema_has_aux_objects_ref;
         readonly attribute AuxObjectHasAttrAssignmentSet aux_object_has_attr_assignment_set_ref;
         readonly attribute SchemaHasCategoryTaxonomy schema_has_category_taxonomy_ref;
         readonly attribute SchemaHasFunctionSettings schema_has_function_settings_ref;
         readonly attribute SchemaHasMiningModel schema_has_mining_model_ref;
         readonly attribute SchemaHasMiningTask schema_has_mining_task_ref;
         readonly attribute SchemaHasMiningResult schema_has_mining_result_ref;
      };
   }; // end of module EntryPointModule

   interface MiningCoreModulePackageFactory
   {
      MiningCoreModulePackage create_mining_core_module_package ()
         raises (Reflective::MofError);
   };

   interface MiningCoreModulePackage : Reflective::RefPackage
   {
      readonly attribute TransformationModule::TransformationModulePackage transformation_ref;
      readonly attribute CoreModule::CoreModulePackage core_ref;
      readonly attribute MiningDataModule::MiningDataModulePackage mining_data_module_ref;
      readonly attribute MiningFunctionSettingsModule::MiningFunctionSettingsModulePackage mining_function_settings_module_ref;
      readonly attribute MiningModelModule::MiningModelModulePackage mining_model_module_ref;
      readonly attribute MiningResultModule::MiningResultModulePackage mining_result_module_ref;
      readonly attribute MiningTaskModule::MiningTaskModulePackage mining_task_module_ref;
      readonly attribute EntryPointModule::EntryPointModulePackage entry_point_module_ref;
   };
};

#endif