/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2001 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __IR3_H__
#define __IR3_H__


#include <mico/ir_base.h>
#include <mico/ir.h>



namespace CORBA {

namespace ComponentIR {


class ComponentDef;
typedef ComponentDef *ComponentDef_ptr;
typedef ComponentDef_ptr ComponentDefRef;
typedef ObjVar<ComponentDef> ComponentDef_var;
typedef ObjOut<ComponentDef> ComponentDef_out;

class ProvidesDef;
typedef ProvidesDef *ProvidesDef_ptr;
typedef ProvidesDef_ptr ProvidesDefRef;
typedef ObjVar<ProvidesDef> ProvidesDef_var;
typedef ObjOut<ProvidesDef> ProvidesDef_out;

class UsesDef;
typedef UsesDef *UsesDef_ptr;
typedef UsesDef_ptr UsesDefRef;
typedef ObjVar<UsesDef> UsesDef_var;
typedef ObjOut<UsesDef> UsesDef_out;

class EmitsDef;
typedef EmitsDef *EmitsDef_ptr;
typedef EmitsDef_ptr EmitsDefRef;
typedef ObjVar<EmitsDef> EmitsDef_var;
typedef ObjOut<EmitsDef> EmitsDef_out;

class PublishesDef;
typedef PublishesDef *PublishesDef_ptr;
typedef PublishesDef_ptr PublishesDefRef;
typedef ObjVar<PublishesDef> PublishesDef_var;
typedef ObjOut<PublishesDef> PublishesDef_out;

class ConsumesDef;
typedef ConsumesDef *ConsumesDef_ptr;
typedef ConsumesDef_ptr ConsumesDefRef;
typedef ObjVar<ConsumesDef> ConsumesDef_var;
typedef ObjOut<ConsumesDef> ConsumesDef_out;


/*
 * Base class and common definitions for interface ComponentDef
 */

class ComponentDef : 
  virtual public ::CORBA::InterfaceDef
{
  public:
    typedef ::CORBA::InterfaceDef _VCHACK__CORBA__InterfaceDef;
    virtual ~ComponentDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ComponentDef_ptr _ptr_type;
    typedef ComponentDef_var _var_type;
    #endif

    static ComponentDef_ptr _narrow( CORBA::Object_ptr obj );
    static ComponentDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ComponentDef_ptr _duplicate( ComponentDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ComponentDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ComponentDef_ptr base_component() = 0;
    virtual void base_component( ComponentDef_ptr value ) = 0;
    virtual InterfaceDefSeq* supported_interfaces() = 0;
    virtual void supported_interfaces( const InterfaceDefSeq& value ) = 0;

    virtual ProvidesDef_ptr create_provides( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type ) = 0;
    virtual UsesDef_ptr create_uses( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type, CORBA::Boolean is_multiple ) = 0;
    virtual EmitsDef_ptr create_emits( const char* id, const char* name, const char* version, ValueDef_ptr event ) = 0;
    virtual PublishesDef_ptr create_publishes( const char* id, const char* name, const char* version, ValueDef_ptr event ) = 0;
    virtual ConsumesDef_ptr create_consumes( const char* id, const char* name, const char* version, ValueDef_ptr event ) = 0;

  protected:
    ComponentDef() {};
  private:
    ComponentDef( const ComponentDef& );
    void operator=( const ComponentDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ComponentDef;

// Stub for interface ComponentDef
class ComponentDef_stub:
  virtual public ComponentDef,
  virtual public ::CORBA::InterfaceDef_stub
{
  public:
    virtual ~ComponentDef_stub();
    ComponentDef_ptr base_component();
    void base_component( ComponentDef_ptr value );
    InterfaceDefSeq* supported_interfaces();
    void supported_interfaces( const InterfaceDefSeq& value );

    ProvidesDef_ptr create_provides( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type );
    UsesDef_ptr create_uses( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type, CORBA::Boolean is_multiple );
    EmitsDef_ptr create_emits( const char* id, const char* name, const char* version, ValueDef_ptr event );
    PublishesDef_ptr create_publishes( const char* id, const char* name, const char* version, ValueDef_ptr event );
    ConsumesDef_ptr create_consumes( const char* id, const char* name, const char* version, ValueDef_ptr event );

  private:
    void operator=( const ComponentDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class ComponentDef_stub_clp :
  virtual public ComponentDef_stub,
  virtual public ::CORBA::InterfaceDef_stub_clp
{
  public:
    ComponentDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ComponentDef_stub_clp ();
    ComponentDef_ptr base_component();
    void base_component( ComponentDef_ptr value );
    InterfaceDefSeq* supported_interfaces();
    void supported_interfaces( const InterfaceDefSeq& value );

    ProvidesDef_ptr create_provides( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type );
    UsesDef_ptr create_uses( const char* id, const char* name, const char* version, InterfaceDef_ptr interface_type, CORBA::Boolean is_multiple );
    EmitsDef_ptr create_emits( const char* id, const char* name, const char* version, ValueDef_ptr event );
    PublishesDef_ptr create_publishes( const char* id, const char* name, const char* version, ValueDef_ptr event );
    ConsumesDef_ptr create_consumes( const char* id, const char* name, const char* version, ValueDef_ptr event );

  protected:
    ComponentDef_stub_clp ();
  private:
    void operator=( const ComponentDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class HomeDef;
typedef HomeDef *HomeDef_ptr;
typedef HomeDef_ptr HomeDefRef;
typedef ObjVar<HomeDef> HomeDef_var;
typedef ObjOut<HomeDef> HomeDef_out;

class FactoryDef;
typedef FactoryDef *FactoryDef_ptr;
typedef FactoryDef_ptr FactoryDefRef;
typedef ObjVar<FactoryDef> FactoryDef_var;
typedef ObjOut<FactoryDef> FactoryDef_out;

class FinderDef;
typedef FinderDef *FinderDef_ptr;
typedef FinderDef_ptr FinderDefRef;
typedef ObjVar<FinderDef> FinderDef_var;
typedef ObjOut<FinderDef> FinderDef_out;


/*
 * Base class and common definitions for interface HomeDef
 */

class HomeDef : 
  virtual public ::CORBA::InterfaceDef
{
  public:
    typedef ::CORBA::InterfaceDef _VCHACK__CORBA__InterfaceDef;
    virtual ~HomeDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef HomeDef_ptr _ptr_type;
    typedef HomeDef_var _var_type;
    #endif

    static HomeDef_ptr _narrow( CORBA::Object_ptr obj );
    static HomeDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static HomeDef_ptr _duplicate( HomeDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static HomeDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual HomeDef_ptr base_home() = 0;
    virtual void base_home( HomeDef_ptr value ) = 0;
    virtual ComponentDef_ptr managed_component() = 0;
    virtual void managed_component( ComponentDef_ptr value ) = 0;
    virtual ValueDef_ptr primary_key() = 0;
    virtual void primary_key( ValueDef_ptr value ) = 0;

    virtual FactoryDef_ptr create_factory( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions ) = 0;
    virtual FinderDef_ptr create_finder( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions ) = 0;

  protected:
    HomeDef() {};
  private:
    HomeDef( const HomeDef& );
    void operator=( const HomeDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_HomeDef;

// Stub for interface HomeDef
class HomeDef_stub:
  virtual public HomeDef,
  virtual public ::CORBA::InterfaceDef_stub
{
  public:
    virtual ~HomeDef_stub();
    HomeDef_ptr base_home();
    void base_home( HomeDef_ptr value );
    ComponentDef_ptr managed_component();
    void managed_component( ComponentDef_ptr value );
    ValueDef_ptr primary_key();
    void primary_key( ValueDef_ptr value );

    FactoryDef_ptr create_factory( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions );
    FinderDef_ptr create_finder( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions );

  private:
    void operator=( const HomeDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class HomeDef_stub_clp :
  virtual public HomeDef_stub,
  virtual public ::CORBA::InterfaceDef_stub_clp
{
  public:
    HomeDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~HomeDef_stub_clp ();
    HomeDef_ptr base_home();
    void base_home( HomeDef_ptr value );
    ComponentDef_ptr managed_component();
    void managed_component( ComponentDef_ptr value );
    ValueDef_ptr primary_key();
    void primary_key( ValueDef_ptr value );

    FactoryDef_ptr create_factory( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions );
    FinderDef_ptr create_finder( const char* id, const char* name, const char* version, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions );

  protected:
    HomeDef_stub_clp ();
  private:
    void operator=( const HomeDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class Container;
typedef Container *Container_ptr;
typedef Container_ptr ContainerRef;
typedef ObjVar<Container> Container_var;
typedef ObjOut<Container> Container_out;


/*
 * Base class and common definitions for interface Container
 */

class Container : 
  virtual public ::CORBA::Container
{
  public:
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    virtual ~Container();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Container_ptr _ptr_type;
    typedef Container_var _var_type;
    #endif

    static Container_ptr _narrow( CORBA::Object_ptr obj );
    static Container_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Container_ptr _duplicate( Container_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Container_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ComponentDef_ptr create_component( const char* id, const char* name, const char* version, ComponentDef_ptr base_component, const InterfaceDefSeq& supports_interfaces ) = 0;
    virtual HomeDef_ptr create_home( const char* id, const char* name, const char* version, HomeDef_ptr base_home, ComponentDef_ptr managed_component, ValueDef_ptr primary_key ) = 0;

  protected:
    Container() {};
  private:
    Container( const Container& );
    void operator=( const Container& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_Container;

// Stub for interface Container
class Container_stub:
  virtual public Container,
  virtual public ::CORBA::Container_stub
{
  public:
    virtual ~Container_stub();
    ComponentDef_ptr create_component( const char* id, const char* name, const char* version, ComponentDef_ptr base_component, const InterfaceDefSeq& supports_interfaces );
    HomeDef_ptr create_home( const char* id, const char* name, const char* version, HomeDef_ptr base_home, ComponentDef_ptr managed_component, ValueDef_ptr primary_key );

  private:
    void operator=( const Container_stub& );
};

#ifndef MICO_CONF_NO_POA

class Container_stub_clp :
  virtual public Container_stub,
  virtual public ::CORBA::Container_stub_clp
{
  public:
    Container_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Container_stub_clp ();
    ComponentDef_ptr create_component( const char* id, const char* name, const char* version, ComponentDef_ptr base_component, const InterfaceDefSeq& supports_interfaces );
    HomeDef_ptr create_home( const char* id, const char* name, const char* version, HomeDef_ptr base_home, ComponentDef_ptr managed_component, ValueDef_ptr primary_key );

  protected:
    Container_stub_clp ();
  private:
    void operator=( const Container_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class ModuleDef;
typedef ModuleDef *ModuleDef_ptr;
typedef ModuleDef_ptr ModuleDefRef;
typedef ObjVar<ModuleDef> ModuleDef_var;
typedef ObjOut<ModuleDef> ModuleDef_out;


/*
 * Base class and common definitions for interface ModuleDef
 */

class ModuleDef : 
  virtual public ::CORBA::ComponentIR::Container,
  virtual public ::CORBA::ModuleDef
{
  public:
    typedef ::CORBA::ComponentIR::Container _VCHACK__CORBA__ComponentIR__Container;
    typedef ::CORBA::ModuleDef _VCHACK__CORBA__ModuleDef;
    virtual ~ModuleDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ModuleDef_ptr _ptr_type;
    typedef ModuleDef_var _var_type;
    #endif

    static ModuleDef_ptr _narrow( CORBA::Object_ptr obj );
    static ModuleDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ModuleDef_ptr _duplicate( ModuleDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ModuleDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ModuleDef() {};
  private:
    ModuleDef( const ModuleDef& );
    void operator=( const ModuleDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ModuleDef;

// Stub for interface ModuleDef
class ModuleDef_stub:
  virtual public ModuleDef,
  virtual public ::CORBA::ComponentIR::Container_stub,
  virtual public ::CORBA::ModuleDef_stub
{
  public:
    virtual ~ModuleDef_stub();
  private:
    void operator=( const ModuleDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class ModuleDef_stub_clp :
  virtual public ModuleDef_stub,
  virtual public ::CORBA::ComponentIR::Container_stub_clp,
  virtual public ::CORBA::ModuleDef_stub_clp
{
  public:
    ModuleDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ModuleDef_stub_clp ();
  protected:
    ModuleDef_stub_clp ();
  private:
    void operator=( const ModuleDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class Repository;
typedef Repository *Repository_ptr;
typedef Repository_ptr RepositoryRef;
typedef ObjVar<Repository> Repository_var;
typedef ObjOut<Repository> Repository_out;


/*
 * Base class and common definitions for interface Repository
 */

class Repository : 
  virtual public ::CORBA::ComponentIR::Container,
  virtual public ::CORBA::Repository
{
  public:
    typedef ::CORBA::ComponentIR::Container _VCHACK__CORBA__ComponentIR__Container;
    typedef ::CORBA::Repository _VCHACK__CORBA__Repository;
    virtual ~Repository();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Repository_ptr _ptr_type;
    typedef Repository_var _var_type;
    #endif

    static Repository_ptr _narrow( CORBA::Object_ptr obj );
    static Repository_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Repository_ptr _duplicate( Repository_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Repository_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    Repository() {};
  private:
    Repository( const Repository& );
    void operator=( const Repository& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_Repository;

// Stub for interface Repository
class Repository_stub:
  virtual public Repository,
  virtual public ::CORBA::ComponentIR::Container_stub,
  virtual public ::CORBA::Repository_stub
{
  public:
    virtual ~Repository_stub();
  private:
    void operator=( const Repository_stub& );
};

#ifndef MICO_CONF_NO_POA

class Repository_stub_clp :
  virtual public Repository_stub,
  virtual public ::CORBA::ComponentIR::Container_stub_clp,
  virtual public ::CORBA::Repository_stub_clp
{
  public:
    Repository_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Repository_stub_clp ();
  protected:
    Repository_stub_clp ();
  private:
    void operator=( const Repository_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface ProvidesDef
 */

class ProvidesDef : 
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~ProvidesDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ProvidesDef_ptr _ptr_type;
    typedef ProvidesDef_var _var_type;
    #endif

    static ProvidesDef_ptr _narrow( CORBA::Object_ptr obj );
    static ProvidesDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ProvidesDef_ptr _duplicate( ProvidesDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ProvidesDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual InterfaceDef_ptr interface_type() = 0;
    virtual void interface_type( InterfaceDef_ptr value ) = 0;

  protected:
    ProvidesDef() {};
  private:
    ProvidesDef( const ProvidesDef& );
    void operator=( const ProvidesDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ProvidesDef;

// Stub for interface ProvidesDef
class ProvidesDef_stub:
  virtual public ProvidesDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~ProvidesDef_stub();
    InterfaceDef_ptr interface_type();
    void interface_type( InterfaceDef_ptr value );

  private:
    void operator=( const ProvidesDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class ProvidesDef_stub_clp :
  virtual public ProvidesDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    ProvidesDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ProvidesDef_stub_clp ();
    InterfaceDef_ptr interface_type();
    void interface_type( InterfaceDef_ptr value );

  protected:
    ProvidesDef_stub_clp ();
  private:
    void operator=( const ProvidesDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

struct ProvidesDescription;
typedef TVarVar<ProvidesDescription> ProvidesDescription_var;
typedef TVarOut<ProvidesDescription> ProvidesDescription_out;


struct ProvidesDescription {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef ProvidesDescription_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ProvidesDescription();
  ~ProvidesDescription();
  ProvidesDescription( const ProvidesDescription& s );
  ProvidesDescription& operator=( const ProvidesDescription& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryId_var interface_type;
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ProvidesDescription;


/*
 * Base class and common definitions for interface UsesDef
 */

class UsesDef : 
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~UsesDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef UsesDef_ptr _ptr_type;
    typedef UsesDef_var _var_type;
    #endif

    static UsesDef_ptr _narrow( CORBA::Object_ptr obj );
    static UsesDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static UsesDef_ptr _duplicate( UsesDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static UsesDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual InterfaceDef_ptr interface_type() = 0;
    virtual void interface_type( InterfaceDef_ptr value ) = 0;
    virtual CORBA::Boolean is_multiple() = 0;
    virtual void is_multiple( CORBA::Boolean value ) = 0;

  protected:
    UsesDef() {};
  private:
    UsesDef( const UsesDef& );
    void operator=( const UsesDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_UsesDef;

// Stub for interface UsesDef
class UsesDef_stub:
  virtual public UsesDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~UsesDef_stub();
    InterfaceDef_ptr interface_type();
    void interface_type( InterfaceDef_ptr value );
    CORBA::Boolean is_multiple();
    void is_multiple( CORBA::Boolean value );

  private:
    void operator=( const UsesDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class UsesDef_stub_clp :
  virtual public UsesDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    UsesDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~UsesDef_stub_clp ();
    InterfaceDef_ptr interface_type();
    void interface_type( InterfaceDef_ptr value );
    CORBA::Boolean is_multiple();
    void is_multiple( CORBA::Boolean value );

  protected:
    UsesDef_stub_clp ();
  private:
    void operator=( const UsesDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

struct UsesDescription;
typedef TVarVar<UsesDescription> UsesDescription_var;
typedef TVarOut<UsesDescription> UsesDescription_out;


struct UsesDescription {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef UsesDescription_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UsesDescription();
  ~UsesDescription();
  UsesDescription( const UsesDescription& s );
  UsesDescription& operator=( const UsesDescription& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryId_var interface_type;
  CORBA::Boolean is_multiple;
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_UsesDescription;

class EventDef;
typedef EventDef *EventDef_ptr;
typedef EventDef_ptr EventDefRef;
typedef ObjVar<EventDef> EventDef_var;
typedef ObjOut<EventDef> EventDef_out;


/*
 * Base class and common definitions for interface EventDef
 */

class EventDef : 
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~EventDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef EventDef_ptr _ptr_type;
    typedef EventDef_var _var_type;
    #endif

    static EventDef_ptr _narrow( CORBA::Object_ptr obj );
    static EventDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static EventDef_ptr _duplicate( EventDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static EventDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ValueDef_ptr event() = 0;
    virtual void event( ValueDef_ptr value ) = 0;

    virtual CORBA::Boolean is_a( const char* event_id ) = 0;

  protected:
    EventDef() {};
  private:
    EventDef( const EventDef& );
    void operator=( const EventDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_EventDef;

// Stub for interface EventDef
class EventDef_stub:
  virtual public EventDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~EventDef_stub();
    ValueDef_ptr event();
    void event( ValueDef_ptr value );

    CORBA::Boolean is_a( const char* event_id );

  private:
    void operator=( const EventDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class EventDef_stub_clp :
  virtual public EventDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    EventDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~EventDef_stub_clp ();
    ValueDef_ptr event();
    void event( ValueDef_ptr value );

    CORBA::Boolean is_a( const char* event_id );

  protected:
    EventDef_stub_clp ();
  private:
    void operator=( const EventDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

struct EventDescription;
typedef TVarVar<EventDescription> EventDescription_var;
typedef TVarOut<EventDescription> EventDescription_out;


struct EventDescription {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef EventDescription_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  EventDescription();
  ~EventDescription();
  EventDescription( const EventDescription& s );
  EventDescription& operator=( const EventDescription& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryId_var event;
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_EventDescription;


/*
 * Base class and common definitions for interface EmitsDef
 */

class EmitsDef : 
  virtual public ::CORBA::ComponentIR::EventDef
{
  public:
    typedef ::CORBA::ComponentIR::EventDef _VCHACK__CORBA__ComponentIR__EventDef;
    virtual ~EmitsDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef EmitsDef_ptr _ptr_type;
    typedef EmitsDef_var _var_type;
    #endif

    static EmitsDef_ptr _narrow( CORBA::Object_ptr obj );
    static EmitsDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static EmitsDef_ptr _duplicate( EmitsDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static EmitsDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    EmitsDef() {};
  private:
    EmitsDef( const EmitsDef& );
    void operator=( const EmitsDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_EmitsDef;

// Stub for interface EmitsDef
class EmitsDef_stub:
  virtual public EmitsDef,
  virtual public ::CORBA::ComponentIR::EventDef_stub
{
  public:
    virtual ~EmitsDef_stub();
  private:
    void operator=( const EmitsDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class EmitsDef_stub_clp :
  virtual public EmitsDef_stub,
  virtual public ::CORBA::ComponentIR::EventDef_stub_clp
{
  public:
    EmitsDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~EmitsDef_stub_clp ();
  protected:
    EmitsDef_stub_clp ();
  private:
    void operator=( const EmitsDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface PublishesDef
 */

class PublishesDef : 
  virtual public ::CORBA::ComponentIR::EventDef
{
  public:
    typedef ::CORBA::ComponentIR::EventDef _VCHACK__CORBA__ComponentIR__EventDef;
    virtual ~PublishesDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef PublishesDef_ptr _ptr_type;
    typedef PublishesDef_var _var_type;
    #endif

    static PublishesDef_ptr _narrow( CORBA::Object_ptr obj );
    static PublishesDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PublishesDef_ptr _duplicate( PublishesDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PublishesDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    PublishesDef() {};
  private:
    PublishesDef( const PublishesDef& );
    void operator=( const PublishesDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_PublishesDef;

// Stub for interface PublishesDef
class PublishesDef_stub:
  virtual public PublishesDef,
  virtual public ::CORBA::ComponentIR::EventDef_stub
{
  public:
    virtual ~PublishesDef_stub();
  private:
    void operator=( const PublishesDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class PublishesDef_stub_clp :
  virtual public PublishesDef_stub,
  virtual public ::CORBA::ComponentIR::EventDef_stub_clp
{
  public:
    PublishesDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~PublishesDef_stub_clp ();
  protected:
    PublishesDef_stub_clp ();
  private:
    void operator=( const PublishesDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface ConsumesDef
 */

class ConsumesDef : 
  virtual public ::CORBA::ComponentIR::EventDef
{
  public:
    typedef ::CORBA::ComponentIR::EventDef _VCHACK__CORBA__ComponentIR__EventDef;
    virtual ~ConsumesDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ConsumesDef_ptr _ptr_type;
    typedef ConsumesDef_var _var_type;
    #endif

    static ConsumesDef_ptr _narrow( CORBA::Object_ptr obj );
    static ConsumesDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ConsumesDef_ptr _duplicate( ConsumesDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ConsumesDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ConsumesDef() {};
  private:
    ConsumesDef( const ConsumesDef& );
    void operator=( const ConsumesDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ConsumesDef;

// Stub for interface ConsumesDef
class ConsumesDef_stub:
  virtual public ConsumesDef,
  virtual public ::CORBA::ComponentIR::EventDef_stub
{
  public:
    virtual ~ConsumesDef_stub();
  private:
    void operator=( const ConsumesDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class ConsumesDef_stub_clp :
  virtual public ConsumesDef_stub,
  virtual public ::CORBA::ComponentIR::EventDef_stub_clp
{
  public:
    ConsumesDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ConsumesDef_stub_clp ();
  protected:
    ConsumesDef_stub_clp ();
  private:
    void operator=( const ConsumesDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

typedef SequenceTmpl<ProvidesDescription,MICO_TID_DEF> ProvidesDescriptionSeq;
#ifdef _WINDOWS
static ProvidesDescriptionSeq _dummy_ProvidesDescriptionSeq;
#endif
typedef TSeqVar<SequenceTmpl<ProvidesDescription,MICO_TID_DEF> > ProvidesDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<ProvidesDescription,MICO_TID_DEF> > ProvidesDescriptionSeq_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ProvidesDescriptionSeq;

typedef SequenceTmpl<UsesDescription,MICO_TID_DEF> UsesDescriptionSeq;
#ifdef _WINDOWS
static UsesDescriptionSeq _dummy_UsesDescriptionSeq;
#endif
typedef TSeqVar<SequenceTmpl<UsesDescription,MICO_TID_DEF> > UsesDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<UsesDescription,MICO_TID_DEF> > UsesDescriptionSeq_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_UsesDescriptionSeq;

typedef SequenceTmpl<EventDescription,MICO_TID_DEF> EventDescriptionSeq;
#ifdef _WINDOWS
static EventDescriptionSeq _dummy_EventDescriptionSeq;
#endif
typedef TSeqVar<SequenceTmpl<EventDescription,MICO_TID_DEF> > EventDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<EventDescription,MICO_TID_DEF> > EventDescriptionSeq_out;

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_EventDescriptionSeq;

struct ComponentDescription;
typedef TVarVar<ComponentDescription> ComponentDescription_var;
typedef TVarOut<ComponentDescription> ComponentDescription_out;


struct ComponentDescription {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef ComponentDescription_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ComponentDescription();
  ~ComponentDescription();
  ComponentDescription( const ComponentDescription& s );
  ComponentDescription& operator=( const ComponentDescription& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryId_var base_component;
  RepositoryIdSeq supported_interfaces;
  ProvidesDescriptionSeq provided_interfaces;
  UsesDescriptionSeq used_interfaces;
  EventDescriptionSeq emits_events;
  EventDescriptionSeq publishes_events;
  EventDescriptionSeq consumes_events;
  CORBA::TypeCode_var type;
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_ComponentDescription;


/*
 * Base class and common definitions for interface FactoryDef
 */

class FactoryDef : 
  virtual public ::CORBA::OperationDef
{
  public:
    typedef ::CORBA::OperationDef _VCHACK__CORBA__OperationDef;
    virtual ~FactoryDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FactoryDef_ptr _ptr_type;
    typedef FactoryDef_var _var_type;
    #endif

    static FactoryDef_ptr _narrow( CORBA::Object_ptr obj );
    static FactoryDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FactoryDef_ptr _duplicate( FactoryDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FactoryDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    FactoryDef() {};
  private:
    FactoryDef( const FactoryDef& );
    void operator=( const FactoryDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_FactoryDef;

// Stub for interface FactoryDef
class FactoryDef_stub:
  virtual public FactoryDef,
  virtual public ::CORBA::OperationDef_stub
{
  public:
    virtual ~FactoryDef_stub();
  private:
    void operator=( const FactoryDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class FactoryDef_stub_clp :
  virtual public FactoryDef_stub,
  virtual public ::CORBA::OperationDef_stub_clp
{
  public:
    FactoryDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FactoryDef_stub_clp ();
  protected:
    FactoryDef_stub_clp ();
  private:
    void operator=( const FactoryDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface FinderDef
 */

class FinderDef : 
  virtual public ::CORBA::OperationDef
{
  public:
    typedef ::CORBA::OperationDef _VCHACK__CORBA__OperationDef;
    virtual ~FinderDef();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FinderDef_ptr _ptr_type;
    typedef FinderDef_var _var_type;
    #endif

    static FinderDef_ptr _narrow( CORBA::Object_ptr obj );
    static FinderDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FinderDef_ptr _duplicate( FinderDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FinderDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    FinderDef() {};
  private:
    FinderDef( const FinderDef& );
    void operator=( const FinderDef& );
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_FinderDef;

// Stub for interface FinderDef
class FinderDef_stub:
  virtual public FinderDef,
  virtual public ::CORBA::OperationDef_stub
{
  public:
    virtual ~FinderDef_stub();
  private:
    void operator=( const FinderDef_stub& );
};

#ifndef MICO_CONF_NO_POA

class FinderDef_stub_clp :
  virtual public FinderDef_stub,
  virtual public ::CORBA::OperationDef_stub_clp
{
  public:
    FinderDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FinderDef_stub_clp ();
  protected:
    FinderDef_stub_clp ();
  private:
    void operator=( const FinderDef_stub_clp & );
};

#endif // MICO_CONF_NO_POA

struct HomeDescription;
typedef TVarVar<HomeDescription> HomeDescription_var;
typedef TVarOut<HomeDescription> HomeDescription_out;


struct HomeDescription {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef HomeDescription_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  HomeDescription();
  ~HomeDescription();
  HomeDescription( const HomeDescription& s );
  HomeDescription& operator=( const HomeDescription& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryId_var base_home;
  RepositoryId_var managed_component;
  ValueDescription primary_key;
  OpDescriptionSeq factories;
  OpDescriptionSeq finders;
  OpDescriptionSeq operations;
  AttrDescriptionSeq attributes;
  CORBA::TypeCode_var type;
};

MICO_EXPORT_VAR_DECL CORBA::TypeCodeConst _tc_HomeDescription;

}
}


#ifndef MICO_CONF_NO_POA



namespace POA_CORBA {

namespace ComponentIR {


class ComponentDef : 
  virtual public POA_CORBA::InterfaceDef
{
  public:
    virtual ~ComponentDef ();
    CORBA::ComponentIR::ComponentDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ComponentDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ComponentIR::ComponentDef_ptr base_component() = 0;
    virtual void base_component( CORBA::ComponentIR::ComponentDef_ptr value ) = 0;
    virtual CORBA::InterfaceDefSeq* supported_interfaces() = 0;
    virtual void supported_interfaces( const CORBA::InterfaceDefSeq& value ) = 0;

    virtual CORBA::ComponentIR::ProvidesDef_ptr create_provides( const char* id, const char* name, const char* version, CORBA::InterfaceDef_ptr interface_type ) = 0;
    virtual CORBA::ComponentIR::UsesDef_ptr create_uses( const char* id, const char* name, const char* version, CORBA::InterfaceDef_ptr interface_type, CORBA::Boolean is_multiple ) = 0;
    virtual CORBA::ComponentIR::EmitsDef_ptr create_emits( const char* id, const char* name, const char* version, CORBA::ValueDef_ptr event ) = 0;
    virtual CORBA::ComponentIR::PublishesDef_ptr create_publishes( const char* id, const char* name, const char* version, CORBA::ValueDef_ptr event ) = 0;
    virtual CORBA::ComponentIR::ConsumesDef_ptr create_consumes( const char* id, const char* name, const char* version, CORBA::ValueDef_ptr event ) = 0;

  protected:
    ComponentDef () {};

  private:
    ComponentDef (const ComponentDef &);
    void operator= (const ComponentDef &);
};

class HomeDef : 
  virtual public POA_CORBA::InterfaceDef
{
  public:
    virtual ~HomeDef ();
    CORBA::ComponentIR::HomeDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static HomeDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ComponentIR::HomeDef_ptr base_home() = 0;
    virtual void base_home( CORBA::ComponentIR::HomeDef_ptr value ) = 0;
    virtual CORBA::ComponentIR::ComponentDef_ptr managed_component() = 0;
    virtual void managed_component( CORBA::ComponentIR::ComponentDef_ptr value ) = 0;
    virtual CORBA::ValueDef_ptr primary_key() = 0;
    virtual void primary_key( CORBA::ValueDef_ptr value ) = 0;

    virtual CORBA::ComponentIR::FactoryDef_ptr create_factory( const char* id, const char* name, const char* version, const CORBA::ParDescriptionSeq& params, const CORBA::ExceptionDefSeq& exceptions ) = 0;
    virtual CORBA::ComponentIR::FinderDef_ptr create_finder( const char* id, const char* name, const char* version, const CORBA::ParDescriptionSeq& params, const CORBA::ExceptionDefSeq& exceptions ) = 0;

  protected:
    HomeDef () {};

  private:
    HomeDef (const HomeDef &);
    void operator= (const HomeDef &);
};

class Container : 
  virtual public POA_CORBA::Container
{
  public:
    virtual ~Container ();
    CORBA::ComponentIR::Container_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Container * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ComponentIR::ComponentDef_ptr create_component( const char* id, const char* name, const char* version, CORBA::ComponentIR::ComponentDef_ptr base_component, const CORBA::InterfaceDefSeq& supports_interfaces ) = 0;
    virtual CORBA::ComponentIR::HomeDef_ptr create_home( const char* id, const char* name, const char* version, CORBA::ComponentIR::HomeDef_ptr base_home, CORBA::ComponentIR::ComponentDef_ptr managed_component, CORBA::ValueDef_ptr primary_key ) = 0;

  protected:
    Container () {};

  private:
    Container (const Container &);
    void operator= (const Container &);
};

class ModuleDef : 
  virtual public POA_CORBA::ComponentIR::Container,
  virtual public POA_CORBA::ModuleDef
{
  public:
    virtual ~ModuleDef ();
    CORBA::ComponentIR::ModuleDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ModuleDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ModuleDef () {};

  private:
    ModuleDef (const ModuleDef &);
    void operator= (const ModuleDef &);
};

class Repository : 
  virtual public POA_CORBA::ComponentIR::Container,
  virtual public POA_CORBA::Repository
{
  public:
    virtual ~Repository ();
    CORBA::ComponentIR::Repository_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Repository * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    Repository () {};

  private:
    Repository (const Repository &);
    void operator= (const Repository &);
};

class ProvidesDef : 
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~ProvidesDef ();
    CORBA::ComponentIR::ProvidesDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ProvidesDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::InterfaceDef_ptr interface_type() = 0;
    virtual void interface_type( CORBA::InterfaceDef_ptr value ) = 0;

  protected:
    ProvidesDef () {};

  private:
    ProvidesDef (const ProvidesDef &);
    void operator= (const ProvidesDef &);
};

class UsesDef : 
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~UsesDef ();
    CORBA::ComponentIR::UsesDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static UsesDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::InterfaceDef_ptr interface_type() = 0;
    virtual void interface_type( CORBA::InterfaceDef_ptr value ) = 0;
    virtual CORBA::Boolean is_multiple() = 0;
    virtual void is_multiple( CORBA::Boolean value ) = 0;

  protected:
    UsesDef () {};

  private:
    UsesDef (const UsesDef &);
    void operator= (const UsesDef &);
};

class EventDef : 
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~EventDef ();
    CORBA::ComponentIR::EventDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static EventDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ValueDef_ptr event() = 0;
    virtual void event( CORBA::ValueDef_ptr value ) = 0;

    virtual CORBA::Boolean is_a( const char* event_id ) = 0;

  protected:
    EventDef () {};

  private:
    EventDef (const EventDef &);
    void operator= (const EventDef &);
};

class EmitsDef : 
  virtual public POA_CORBA::ComponentIR::EventDef
{
  public:
    virtual ~EmitsDef ();
    CORBA::ComponentIR::EmitsDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static EmitsDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    EmitsDef () {};

  private:
    EmitsDef (const EmitsDef &);
    void operator= (const EmitsDef &);
};

class PublishesDef : 
  virtual public POA_CORBA::ComponentIR::EventDef
{
  public:
    virtual ~PublishesDef ();
    CORBA::ComponentIR::PublishesDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static PublishesDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    PublishesDef () {};

  private:
    PublishesDef (const PublishesDef &);
    void operator= (const PublishesDef &);
};

class ConsumesDef : 
  virtual public POA_CORBA::ComponentIR::EventDef
{
  public:
    virtual ~ConsumesDef ();
    CORBA::ComponentIR::ConsumesDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ConsumesDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ConsumesDef () {};

  private:
    ConsumesDef (const ConsumesDef &);
    void operator= (const ConsumesDef &);
};

class FactoryDef : 
  virtual public POA_CORBA::OperationDef
{
  public:
    virtual ~FactoryDef ();
    CORBA::ComponentIR::FactoryDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FactoryDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    FactoryDef () {};

  private:
    FactoryDef (const FactoryDef &);
    void operator= (const FactoryDef &);
};

class FinderDef : 
  virtual public POA_CORBA::OperationDef
{
  public:
    virtual ~FinderDef ();
    CORBA::ComponentIR::FinderDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FinderDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    FinderDef () {};

  private:
    FinderDef (const FinderDef &);
    void operator= (const FinderDef &);
};

}
}


#endif // MICO_CONF_NO_POA

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::ComponentDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::ComponentDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::ComponentDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ComponentDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::HomeDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::HomeDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::HomeDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_HomeDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::Container_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::Container_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::Container_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_Container;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::ModuleDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::ModuleDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::ModuleDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ModuleDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::Repository_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::Repository_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::Repository_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_Repository;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::ProvidesDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::ProvidesDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::ProvidesDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ProvidesDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ComponentIR::ProvidesDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ComponentIR::ProvidesDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ComponentIR::ProvidesDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ComponentIR::ProvidesDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ProvidesDescription;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::UsesDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::UsesDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::UsesDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_UsesDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ComponentIR::UsesDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ComponentIR::UsesDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ComponentIR::UsesDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ComponentIR::UsesDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_UsesDescription;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::EventDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::EventDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::EventDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_EventDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ComponentIR::EventDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ComponentIR::EventDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ComponentIR::EventDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ComponentIR::EventDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_EventDescription;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::EmitsDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::EmitsDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::EmitsDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_EmitsDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::PublishesDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::PublishesDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::PublishesDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_PublishesDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::ConsumesDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::ConsumesDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::ConsumesDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ConsumesDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ComponentIR::ComponentDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ComponentIR::ComponentDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ComponentIR::ComponentDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ComponentIR::ComponentDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_ComponentDescription;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::FactoryDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::FactoryDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::FactoryDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_FactoryDef;

void operator<<=( CORBA::Any &a, const CORBA::ComponentIR::FinderDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ComponentIR::FinderDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ComponentIR::FinderDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_FinderDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ComponentIR::HomeDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ComponentIR::HomeDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ComponentIR::HomeDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ComponentIR::HomeDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ComponentIR_HomeDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::ProvidesDescription,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::ProvidesDescription,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::ProvidesDescription,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::ProvidesDescription,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ComponentIR_ProvidesDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::UsesDescription,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::UsesDescription,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::UsesDescription,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::UsesDescription,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ComponentIR_UsesDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::EventDescription,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::EventDescription,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ComponentIR::EventDescription,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ComponentIR::EventDescription,MICO_TID_DEF> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ComponentIR_EventDescription;

#endif
