// This file contains the OMG IDL module for the ComponentIDL MOF Repository.
//
// Editor: Dr. Philippe Merle - LIFL & INRIA

#pragma prefix "ccm.omg.org"
#include "BaseIDL.idl"

module ComponentIDL
{
   interface ComponentFeatureClass;
   interface ComponentFeature;
   typedef sequence<ComponentFeature> ComponentFeatureSet;
   interface ComponentDefClass;
   interface ComponentDef;
   typedef sequence<ComponentDef> ComponentDefSet;
   interface ProvidesDefClass;
   interface ProvidesDef;
   typedef sequence<ProvidesDef> ProvidesDefSet;
   interface HomeDefClass;
   interface HomeDef;
   typedef sequence<HomeDef> HomeDefSet;
   interface FactoryDefClass;
   interface FactoryDef;
   typedef sequence<FactoryDef> FactoryDefSet;
   interface FinderDefClass;
   interface FinderDef;
   typedef sequence<FinderDef> FinderDefSet;
   interface EventPortDefClass;
   interface EventPortDef;
   typedef sequence<EventPortDef> EventPortDefSet;
   interface EmitsDefClass;
   interface EmitsDef;
   typedef sequence<EmitsDef> EmitsDefSet;
   interface ConsumesDefClass;
   interface ConsumesDef;
   typedef sequence<ConsumesDef> ConsumesDefSet;
   interface UsesDefClass;
   interface UsesDef;
   typedef sequence<UsesDef> UsesDefSet;
   interface PublishesDefClass;
   interface PublishesDef;
   typedef sequence<PublishesDef> PublishesDefSet;
   interface EventDefClass;
   interface EventDef;
   typedef sequence<EventDef> EventDefSet;
   interface ComponentIDLPackage;

   interface ComponentFeatureClass : Reflective::RefObject
   {
      readonly attribute ComponentFeatureSet all_of_type_component_feature;
   };

   interface ComponentFeature : ComponentFeatureClass
   {
   }; // end of interface ComponentFeature

   interface ComponentDefClass : BaseIDL::InterfaceDefClass, ComponentFeatureClass
   {
      readonly attribute ComponentDefSet all_of_type_component_def;
      readonly attribute ComponentDefSet all_of_class_component_def;
      ComponentDef create_component_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_abstract,
         in boolean is_local)
         raises (Reflective::MofError);
   };

   interface ComponentDef : ComponentDefClass, BaseIDL::InterfaceDef, ComponentFeature
   {
      ProvidesDefSet facet ()
         raises (Reflective::MofError);
      void set_facet (in ProvidesDefSet new_value)
         raises (Reflective::MofError);
      void unset_facet ()
         raises (Reflective::MofError);
      void add_facet (in ProvidesDef new_element)
         raises (Reflective::MofError);
      void modify_facet (
         in ProvidesDef old_element,
         in ProvidesDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_facet (in ProvidesDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      EmitsDefSet emits ()
         raises (Reflective::MofError);
      void set_emits (in EmitsDefSet new_value)
         raises (Reflective::MofError);
      void unset_emits ()
         raises (Reflective::MofError);
      void add_emits (in EmitsDef new_element)
         raises (Reflective::MofError);
      void modify_emits (
         in EmitsDef old_element,
         in EmitsDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_emits (in EmitsDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ConsumesDefSet consumes ()
         raises (Reflective::MofError);
      void set_consumes (in ConsumesDefSet new_value)
         raises (Reflective::MofError);
      void unset_consumes ()
         raises (Reflective::MofError);
      void add_consumes (in ConsumesDef new_element)
         raises (Reflective::MofError);
      void modify_consumes (
         in ConsumesDef old_element,
         in ConsumesDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_consumes (in ConsumesDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      UsesDefSet receptacle ()
         raises (Reflective::MofError);
      void set_receptacle (in UsesDefSet new_value)
         raises (Reflective::MofError);
      void unset_receptacle ()
         raises (Reflective::MofError);
      void add_receptacle (in UsesDef new_element)
         raises (Reflective::MofError);
      void modify_receptacle (
         in UsesDef old_element,
         in UsesDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_receptacle (in UsesDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      BaseIDL::InterfaceDefSet supports ()
         raises (Reflective::MofError);
      void set_supports (in BaseIDL::InterfaceDefSet new_value)
         raises (Reflective::MofError);
      void unset_supports ()
         raises (Reflective::MofError);
      void add_supports (in BaseIDL::InterfaceDef new_element)
         raises (Reflective::MofError);
      void modify_supports (
         in BaseIDL::InterfaceDef old_element,
         in BaseIDL::InterfaceDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_supports (in BaseIDL::InterfaceDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      PublishesDefSet publishes ()
         raises (Reflective::MofError);
      void set_publishes (in PublishesDefSet new_value)
         raises (Reflective::MofError);
      void unset_publishes ()
         raises (Reflective::MofError);
      void add_publishes (in PublishesDef new_element)
         raises (Reflective::MofError);
      void modify_publishes (
         in PublishesDef old_element,
         in PublishesDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_publishes (in PublishesDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentDef

   interface ProvidesDefClass : BaseIDL::ContainedClass, ComponentFeatureClass
   {
      readonly attribute ProvidesDefSet all_of_type_provides_def;
      readonly attribute ProvidesDefSet all_of_class_provides_def;
      ProvidesDef create_provides_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface ProvidesDef : ProvidesDefClass, BaseIDL::Contained, ComponentFeature
   {
      BaseIDL::InterfaceDef provides ()
         raises (Reflective::MofError);
      void set_provides (in BaseIDL::InterfaceDef new_value)
         raises (Reflective::MofError);
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
   }; // end of interface ProvidesDef

   interface HomeDefClass : BaseIDL::InterfaceDefClass
   {
      readonly attribute HomeDefSet all_of_type_home_def;
      readonly attribute HomeDefSet all_of_class_home_def;
      HomeDef create_home_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_abstract,
         in boolean is_local)
         raises (Reflective::MofError);
   };

   interface HomeDef : HomeDefClass, BaseIDL::InterfaceDef
   {
      FinderDefSet finder ()
         raises (Reflective::MofError);
      void set_finder (in FinderDefSet new_value)
         raises (Reflective::MofError);
      void unset_finder ()
         raises (Reflective::MofError);
      void add_finder (in FinderDef new_element)
         raises (Reflective::MofError);
      void modify_finder (
         in FinderDef old_element,
         in FinderDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_finder (in FinderDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
      FactoryDefSet factory ()
         raises (Reflective::MofError);
      void set_factory (in FactoryDefSet new_value)
         raises (Reflective::MofError);
      void unset_factory ()
         raises (Reflective::MofError);
      void add_factory (in FactoryDef new_element)
         raises (Reflective::MofError);
      void modify_factory (
         in FactoryDef old_element,
         in FactoryDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_factory (in FactoryDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
      BaseIDL::ValueDef primary_key ()
         raises (Reflective::NotSet, Reflective::MofError);
      void set_primary_key (in BaseIDL::ValueDef new_value)
         raises (Reflective::MofError);
      void unset_primary_key ()
         raises (Reflective::MofError);
      BaseIDL::InterfaceDefSet supports ()
         raises (Reflective::MofError);
      void set_supports (in BaseIDL::InterfaceDefSet new_value)
         raises (Reflective::MofError);
      void unset_supports ()
         raises (Reflective::MofError);
      void add_supports (in BaseIDL::InterfaceDef new_element)
         raises (Reflective::MofError);
      void modify_supports (
         in BaseIDL::InterfaceDef old_element,
         in BaseIDL::InterfaceDef new_element)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove_supports (in BaseIDL::InterfaceDef old_element)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface HomeDef

   interface FactoryDefClass : BaseIDL::OperationDefClass
   {
      readonly attribute FactoryDefSet all_of_type_factory_def;
      readonly attribute FactoryDefSet all_of_class_factory_def;
      FactoryDef create_factory_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_oneway,
         in BaseIDL::ParameterDef parameters,
         in string contexts)
         raises (Reflective::MofError);
   };

   interface FactoryDef : FactoryDefClass, BaseIDL::OperationDef
   {
      HomeDef home ()
         raises (Reflective::MofError);
      void set_home (in HomeDef new_value)
         raises (Reflective::MofError);
   }; // end of interface FactoryDef

   interface FinderDefClass : BaseIDL::OperationDefClass
   {
      readonly attribute FinderDefSet all_of_type_finder_def;
      readonly attribute FinderDefSet all_of_class_finder_def;
      FinderDef create_finder_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_oneway,
         in BaseIDL::ParameterDef parameters,
         in string contexts)
         raises (Reflective::MofError);
   };

   interface FinderDef : FinderDefClass, BaseIDL::OperationDef
   {
      HomeDef home ()
         raises (Reflective::MofError);
      void set_home (in HomeDef new_value)
         raises (Reflective::MofError);
   }; // end of interface FinderDef

   interface EventPortDefClass : BaseIDL::ContainedClass, ComponentFeatureClass
   {
      readonly attribute EventPortDefSet all_of_type_event_port_def;
   };

   interface EventPortDef : EventPortDefClass, BaseIDL::Contained, ComponentFeature
   {
      EventDef type ()
         raises (Reflective::MofError);
      void set_type (in EventDef new_value)
         raises (Reflective::MofError);
   }; // end of interface EventPortDef

   interface EmitsDefClass : EventPortDefClass, ComponentFeatureClass
   {
      readonly attribute EmitsDefSet all_of_type_emits_def;
      readonly attribute EmitsDefSet all_of_class_emits_def;
      EmitsDef create_emits_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface EmitsDef : EmitsDefClass, EventPortDef, ComponentFeature
   {
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
   }; // end of interface EmitsDef

   interface ConsumesDefClass : EventPortDefClass, ComponentFeatureClass
   {
      readonly attribute ConsumesDefSet all_of_type_consumes_def;
      readonly attribute ConsumesDefSet all_of_class_consumes_def;
      ConsumesDef create_consumes_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface ConsumesDef : ConsumesDefClass, EventPortDef, ComponentFeature
   {
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
   }; // end of interface ConsumesDef

   interface UsesDefClass : BaseIDL::ContainedClass, ComponentFeatureClass
   {
      readonly attribute UsesDefSet all_of_type_uses_def;
      readonly attribute UsesDefSet all_of_class_uses_def;
      UsesDef create_uses_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean multiple)
         raises (Reflective::MofError);
   };

   interface UsesDef : UsesDefClass, BaseIDL::Contained, ComponentFeature
   {
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
      BaseIDL::InterfaceDef uses ()
         raises (Reflective::MofError);
      void set_uses (in BaseIDL::InterfaceDef new_value)
         raises (Reflective::MofError);
      boolean multiple ()
         raises (Reflective::MofError);
      void set_multiple (in boolean new_value)
         raises (Reflective::MofError);
   }; // end of interface UsesDef

   interface PublishesDefClass : EventPortDefClass, ComponentFeatureClass
   {
      readonly attribute PublishesDefSet all_of_type_publishes_def;
      readonly attribute PublishesDefSet all_of_class_publishes_def;
      PublishesDef create_publishes_def (
         in string identifier,
         in string repository_id,
         in string version)
         raises (Reflective::MofError);
   };

   interface PublishesDef : PublishesDefClass, EventPortDef, ComponentFeature
   {
      ComponentDef component ()
         raises (Reflective::MofError);
      void set_component (in ComponentDef new_value)
         raises (Reflective::MofError);
   }; // end of interface PublishesDef

   interface EventDefClass : BaseIDL::ValueDefClass
   {
      readonly attribute EventDefSet all_of_type_event_def;
      readonly attribute EventDefSet all_of_class_event_def;
      EventDef create_event_def (
         in string identifier,
         in string repository_id,
         in string version,
         in boolean is_abstract,
         in boolean is_custom,
         in boolean is_truncatable)
         raises (Reflective::MofError);
   };

   interface EventDef : EventDefClass, BaseIDL::ValueDef
   {
   }; // end of interface EventDef

   struct ProvidesInterfaceLink
   {
      BaseIDL::InterfaceDef provides;
      ProvidesDef provides_def;
   };
   typedef sequence<ProvidesInterfaceLink> ProvidesInterfaceLinkSet;

   interface ProvidesInterface : Reflective::RefAssociation
   {
      ProvidesInterfaceLinkSet all_provides_interface_links()
         raises (Reflective::MofError);
      boolean exists (
         in BaseIDL::InterfaceDef provides,
         in ProvidesDef provides_def)
         raises (Reflective::MofError);
      BaseIDL::InterfaceDef provides (in ProvidesDef provides_def)
         raises (Reflective::MofError);
      void add (
         in BaseIDL::InterfaceDef provides,
         in ProvidesDef provides_def)
         raises (Reflective::MofError);
      void modify_provides (
         in BaseIDL::InterfaceDef provides,
         in ProvidesDef provides_def,
         in BaseIDL::InterfaceDef new_provides)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BaseIDL::InterfaceDef provides,
         in ProvidesDef provides_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ProvidesInterface

   struct ComponentFacetLink
   {
      ComponentDef component;
      ProvidesDef facet;
   };
   typedef sequence<ComponentFacetLink> ComponentFacetLinkSet;

   interface ComponentFacet : Reflective::RefAssociation
   {
      ComponentFacetLinkSet all_component_facet_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in ProvidesDef facet)
         raises (Reflective::MofError);
      ComponentDef component (in ProvidesDef facet)
         raises (Reflective::MofError);
      ProvidesDefSet facet (in ComponentDef component)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in ProvidesDef facet)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in ProvidesDef facet,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_facet (
         in ComponentDef component,
         in ProvidesDef facet,
         in ProvidesDef new_facet)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in ProvidesDef facet)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentFacet

   struct HomeFinderLink
   {
      HomeDef home;
      FinderDef finder;
   };
   typedef sequence<HomeFinderLink> HomeFinderLinkSet;

   interface HomeFinder : Reflective::RefAssociation
   {
      HomeFinderLinkSet all_home_finder_links()
         raises (Reflective::MofError);
      boolean exists (
         in HomeDef home,
         in FinderDef finder)
         raises (Reflective::MofError);
      HomeDef home (in FinderDef finder)
         raises (Reflective::MofError);
      FinderDefSet finder (in HomeDef home)
         raises (Reflective::MofError);
      void add (
         in HomeDef home,
         in FinderDef finder)
         raises (Reflective::MofError);
      void modify_home (
         in HomeDef home,
         in FinderDef finder,
         in HomeDef new_home)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_finder (
         in HomeDef home,
         in FinderDef finder,
         in FinderDef new_finder)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in HomeDef home,
         in FinderDef finder)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface HomeFinder

   struct ComponentEmitsLink
   {
      ComponentDef component;
      EmitsDef emits;
   };
   typedef sequence<ComponentEmitsLink> ComponentEmitsLinkSet;

   interface ComponentEmits : Reflective::RefAssociation
   {
      ComponentEmitsLinkSet all_component_emits_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in EmitsDef emits)
         raises (Reflective::MofError);
      ComponentDef component (in EmitsDef emits)
         raises (Reflective::MofError);
      EmitsDefSet emits (in ComponentDef component)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in EmitsDef emits)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in EmitsDef emits,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_emits (
         in ComponentDef component,
         in EmitsDef emits,
         in EmitsDef new_emits)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in EmitsDef emits)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentEmits

   struct ComponentConsumesLink
   {
      ComponentDef component;
      ConsumesDef consumes;
   };
   typedef sequence<ComponentConsumesLink> ComponentConsumesLinkSet;

   interface ComponentConsumes : Reflective::RefAssociation
   {
      ComponentConsumesLinkSet all_component_consumes_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in ConsumesDef consumes)
         raises (Reflective::MofError);
      ComponentDef component (in ConsumesDef consumes)
         raises (Reflective::MofError);
      ConsumesDefSet consumes (in ComponentDef component)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in ConsumesDef consumes)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in ConsumesDef consumes,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_consumes (
         in ComponentDef component,
         in ConsumesDef consumes,
         in ConsumesDef new_consumes)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in ConsumesDef consumes)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentConsumes

   struct ComponentReceptacleLink
   {
      ComponentDef component;
      UsesDef receptacle;
   };
   typedef sequence<ComponentReceptacleLink> ComponentReceptacleLinkSet;

   interface ComponentReceptacle : Reflective::RefAssociation
   {
      ComponentReceptacleLinkSet all_component_receptacle_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in UsesDef receptacle)
         raises (Reflective::MofError);
      ComponentDef component (in UsesDef receptacle)
         raises (Reflective::MofError);
      UsesDefSet receptacle (in ComponentDef component)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in UsesDef receptacle)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in UsesDef receptacle,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_receptacle (
         in ComponentDef component,
         in UsesDef receptacle,
         in UsesDef new_receptacle)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in UsesDef receptacle)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentReceptacle

   struct UsesInterfaceLink
   {
      BaseIDL::InterfaceDef uses;
      UsesDef uses_def;
   };
   typedef sequence<UsesInterfaceLink> UsesInterfaceLinkSet;

   interface UsesInterface : Reflective::RefAssociation
   {
      UsesInterfaceLinkSet all_uses_interface_links()
         raises (Reflective::MofError);
      boolean exists (
         in BaseIDL::InterfaceDef uses,
         in UsesDef uses_def)
         raises (Reflective::MofError);
      BaseIDL::InterfaceDef uses (in UsesDef uses_def)
         raises (Reflective::MofError);
      void add (
         in BaseIDL::InterfaceDef uses,
         in UsesDef uses_def)
         raises (Reflective::MofError);
      void modify_uses (
         in BaseIDL::InterfaceDef uses,
         in UsesDef uses_def,
         in BaseIDL::InterfaceDef new_uses)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BaseIDL::InterfaceDef uses,
         in UsesDef uses_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface UsesInterface

   struct ComponentHomeLink
   {
      ComponentDef component;
      HomeDef home;
   };
   typedef sequence<ComponentHomeLink> ComponentHomeLinkSet;

   interface ComponentHome : Reflective::RefAssociation
   {
      ComponentHomeLinkSet all_component_home_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in HomeDef home)
         raises (Reflective::MofError);
      ComponentDef component (in HomeDef home)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in HomeDef home)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in HomeDef home,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in HomeDef home)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentHome

   struct ComponentSupportsLink
   {
      BaseIDL::InterfaceDef supports;
      ComponentDef components;
   };
   typedef sequence<ComponentSupportsLink> ComponentSupportsLinkSet;

   interface ComponentSupports : Reflective::RefAssociation
   {
      ComponentSupportsLinkSet all_component_supports_links()
         raises (Reflective::MofError);
      boolean exists (
         in BaseIDL::InterfaceDef supports,
         in ComponentDef components)
         raises (Reflective::MofError);
      BaseIDL::InterfaceDefSet supports (in ComponentDef components)
         raises (Reflective::MofError);
      void add (
         in BaseIDL::InterfaceDef supports,
         in ComponentDef components)
         raises (Reflective::MofError);
      void modify_supports (
         in BaseIDL::InterfaceDef supports,
         in ComponentDef components,
         in BaseIDL::InterfaceDef new_supports)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BaseIDL::InterfaceDef supports,
         in ComponentDef components)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentSupports

   struct HomeFactoryLink
   {
      HomeDef home;
      FactoryDef factory;
   };
   typedef sequence<HomeFactoryLink> HomeFactoryLinkSet;

   interface HomeFactory : Reflective::RefAssociation
   {
      HomeFactoryLinkSet all_home_factory_links()
         raises (Reflective::MofError);
      boolean exists (
         in HomeDef home,
         in FactoryDef factory)
         raises (Reflective::MofError);
      HomeDef home (in FactoryDef factory)
         raises (Reflective::MofError);
      FactoryDefSet factory (in HomeDef home)
         raises (Reflective::MofError);
      void add (
         in HomeDef home,
         in FactoryDef factory)
         raises (Reflective::MofError);
      void modify_home (
         in HomeDef home,
         in FactoryDef factory,
         in HomeDef new_home)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_factory (
         in HomeDef home,
         in FactoryDef factory,
         in FactoryDef new_factory)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in HomeDef home,
         in FactoryDef factory)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface HomeFactory

   struct ComponentPublishesLink
   {
      ComponentDef component;
      PublishesDef publishes;
   };
   typedef sequence<ComponentPublishesLink> ComponentPublishesLinkSet;

   interface ComponentPublishes : Reflective::RefAssociation
   {
      ComponentPublishesLinkSet all_component_publishes_links()
         raises (Reflective::MofError);
      boolean exists (
         in ComponentDef component,
         in PublishesDef publishes)
         raises (Reflective::MofError);
      ComponentDef component (in PublishesDef publishes)
         raises (Reflective::MofError);
      PublishesDefSet publishes (in ComponentDef component)
         raises (Reflective::MofError);
      void add (
         in ComponentDef component,
         in PublishesDef publishes)
         raises (Reflective::MofError);
      void modify_component (
         in ComponentDef component,
         in PublishesDef publishes,
         in ComponentDef new_component)
         raises (Reflective::NotFound, Reflective::MofError);
      void modify_publishes (
         in ComponentDef component,
         in PublishesDef publishes,
         in PublishesDef new_publishes)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in ComponentDef component,
         in PublishesDef publishes)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ComponentPublishes

   struct EventTypeLink
   {
      EventDef type;
      EventPortDef event;
   };
   typedef sequence<EventTypeLink> EventTypeLinkSet;

   interface EventType : Reflective::RefAssociation
   {
      EventTypeLinkSet all_event_type_links()
         raises (Reflective::MofError);
      boolean exists (
         in EventDef type,
         in EventPortDef event)
         raises (Reflective::MofError);
      EventDef type (in EventPortDef event)
         raises (Reflective::MofError);
      void add (
         in EventDef type,
         in EventPortDef event)
         raises (Reflective::MofError);
      void modify_type (
         in EventDef type,
         in EventPortDef event,
         in EventDef new_type)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in EventDef type,
         in EventPortDef event)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface EventType

   struct APrimaryKeyHomeLink
   {
      BaseIDL::ValueDef primary_key;
      HomeDef home;
   };
   typedef sequence<APrimaryKeyHomeLink> APrimaryKeyHomeLinkSet;

   interface APrimaryKeyHome : Reflective::RefAssociation
   {
      APrimaryKeyHomeLinkSet all_a_primary_key_home_links()
         raises (Reflective::MofError);
      boolean exists (
         in BaseIDL::ValueDef primary_key,
         in HomeDef home)
         raises (Reflective::MofError);
      BaseIDL::ValueDef primary_key (in HomeDef home)
         raises (Reflective::MofError);
      void add (
         in BaseIDL::ValueDef primary_key,
         in HomeDef home)
         raises (Reflective::MofError);
      void modify_primary_key (
         in BaseIDL::ValueDef primary_key,
         in HomeDef home,
         in BaseIDL::ValueDef new_primary_key)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BaseIDL::ValueDef primary_key,
         in HomeDef home)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface APrimaryKeyHome

   struct ASupportsHomeDefLink
   {
      BaseIDL::InterfaceDef supports;
      HomeDef home_def;
   };
   typedef sequence<ASupportsHomeDefLink> ASupportsHomeDefLinkSet;

   interface ASupportsHomeDef : Reflective::RefAssociation
   {
      ASupportsHomeDefLinkSet all_a_supports_home_def_links()
         raises (Reflective::MofError);
      boolean exists (
         in BaseIDL::InterfaceDef supports,
         in HomeDef home_def)
         raises (Reflective::MofError);
      BaseIDL::InterfaceDefSet supports (in HomeDef home_def)
         raises (Reflective::MofError);
      void add (
         in BaseIDL::InterfaceDef supports,
         in HomeDef home_def)
         raises (Reflective::MofError);
      void modify_supports (
         in BaseIDL::InterfaceDef supports,
         in HomeDef home_def,
         in BaseIDL::InterfaceDef new_supports)
         raises (Reflective::NotFound, Reflective::MofError);
      void remove (
         in BaseIDL::InterfaceDef supports,
         in HomeDef home_def)
         raises (Reflective::NotFound, Reflective::MofError);
   }; // end of interface ASupportsHomeDef

   interface ComponentIDLPackageFactory
   {
      ComponentIDLPackage create_component_idl_package ()
         raises (Reflective::MofError);
   };

   interface ComponentIDLPackage : Reflective::RefPackage
   {
      readonly attribute ComponentFeatureClass component_feature_ref;
      readonly attribute ComponentDefClass component_def_ref;
      readonly attribute ProvidesDefClass provides_def_ref;
      readonly attribute HomeDefClass home_def_ref;
      readonly attribute FactoryDefClass factory_def_ref;
      readonly attribute FinderDefClass finder_def_ref;
      readonly attribute EventPortDefClass event_port_def_ref;
      readonly attribute EmitsDefClass emits_def_ref;
      readonly attribute ConsumesDefClass consumes_def_ref;
      readonly attribute UsesDefClass uses_def_ref;
      readonly attribute PublishesDefClass publishes_def_ref;
      readonly attribute EventDefClass event_def_ref;
      readonly attribute ProvidesInterface provides_interface_ref;
      readonly attribute ComponentFacet component_facet_ref;
      readonly attribute HomeFinder home_finder_ref;
      readonly attribute ComponentEmits component_emits_ref;
      readonly attribute ComponentConsumes component_consumes_ref;
      readonly attribute ComponentReceptacle component_receptacle_ref;
      readonly attribute UsesInterface uses_interface_ref;
      readonly attribute ComponentHome component_home_ref;
      readonly attribute ComponentSupports component_supports_ref;
      readonly attribute HomeFactory home_factory_ref;
      readonly attribute ComponentPublishes component_publishes_ref;
      readonly attribute EventType event_type_ref;
      readonly attribute APrimaryKeyHome a_primary_key_home_ref;
      readonly attribute ASupportsHomeDef a_supports_home_def_ref;
   };
}; // end of module ComponentIDL