/*
 *  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 __COSTRADING_H__
#define __COSTRADING_H__





namespace CosTrading {


class Lookup;
typedef Lookup *Lookup_ptr;
typedef Lookup_ptr LookupRef;
typedef ObjVar<Lookup> Lookup_var;
typedef ObjOut<Lookup> Lookup_out;

class Register;
typedef Register *Register_ptr;
typedef Register_ptr RegisterRef;
typedef ObjVar<Register> Register_var;
typedef ObjOut<Register> Register_out;

class Link;
typedef Link *Link_ptr;
typedef Link_ptr LinkRef;
typedef ObjVar<Link> Link_var;
typedef ObjOut<Link> Link_out;

class Proxy;
typedef Proxy *Proxy_ptr;
typedef Proxy_ptr ProxyRef;
typedef ObjVar<Proxy> Proxy_var;
typedef ObjOut<Proxy> Proxy_out;

class Admin;
typedef Admin *Admin_ptr;
typedef Admin_ptr AdminRef;
typedef ObjVar<Admin> Admin_var;
typedef ObjOut<Admin> Admin_out;

class TraderComponents;
typedef TraderComponents *TraderComponents_ptr;
typedef TraderComponents_ptr TraderComponentsRef;
typedef ObjVar<TraderComponents> TraderComponents_var;
typedef ObjOut<TraderComponents> TraderComponents_out;


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

class TraderComponents : 
  virtual public CORBA::Object
{
  public:
    virtual ~TraderComponents();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TraderComponents_ptr _ptr_type;
    typedef TraderComponents_var _var_type;
    #endif

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

    static TraderComponents_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Lookup_ptr lookup_if() = 0;
    virtual Register_ptr register_if() = 0;
    virtual Link_ptr link_if() = 0;
    virtual Proxy_ptr proxy_if() = 0;
    virtual Admin_ptr admin_if() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_TraderComponents;

// Stub for interface TraderComponents
class TraderComponents_stub:
  virtual public TraderComponents
{
  public:
    virtual ~TraderComponents_stub();
    Lookup_ptr lookup_if();
    Register_ptr register_if();
    Link_ptr link_if();
    Proxy_ptr proxy_if();
    Admin_ptr admin_if();

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

class TraderComponents_skel :
  virtual public StaticMethodDispatcher,
  virtual public TraderComponents
{
  public:
    TraderComponents_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~TraderComponents_skel();
    TraderComponents_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    TraderComponents_ptr _this();

};

typedef CORBA::Object TypeRepository;
typedef CORBA::Object_ptr TypeRepository_ptr;
typedef CORBA::ObjectRef TypeRepositoryRef;
typedef CORBA::Object_var TypeRepository_var;
typedef CORBA::Object_out TypeRepository_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_TypeRepository;

class SupportAttributes;
typedef SupportAttributes *SupportAttributes_ptr;
typedef SupportAttributes_ptr SupportAttributesRef;
typedef ObjVar<SupportAttributes> SupportAttributes_var;
typedef ObjOut<SupportAttributes> SupportAttributes_out;


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

class SupportAttributes : 
  virtual public CORBA::Object
{
  public:
    virtual ~SupportAttributes();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef SupportAttributes_ptr _ptr_type;
    typedef SupportAttributes_var _var_type;
    #endif

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

    static SupportAttributes_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean supports_modifiable_properties() = 0;
    virtual CORBA::Boolean supports_dynamic_properties() = 0;
    virtual CORBA::Boolean supports_proxy_offers() = 0;
    virtual TypeRepository_ptr type_repos() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_SupportAttributes;

// Stub for interface SupportAttributes
class SupportAttributes_stub:
  virtual public SupportAttributes
{
  public:
    virtual ~SupportAttributes_stub();
    CORBA::Boolean supports_modifiable_properties();
    CORBA::Boolean supports_dynamic_properties();
    CORBA::Boolean supports_proxy_offers();
    TypeRepository_ptr type_repos();

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

class SupportAttributes_skel :
  virtual public StaticMethodDispatcher,
  virtual public SupportAttributes
{
  public:
    SupportAttributes_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~SupportAttributes_skel();
    SupportAttributes_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    SupportAttributes_ptr _this();

};

enum FollowOption {
  local_only = 0,
  if_no_local,
  always
};

typedef FollowOption& FollowOption_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_FollowOption;

class ImportAttributes;
typedef ImportAttributes *ImportAttributes_ptr;
typedef ImportAttributes_ptr ImportAttributesRef;
typedef ObjVar<ImportAttributes> ImportAttributes_var;
typedef ObjOut<ImportAttributes> ImportAttributes_out;


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

class ImportAttributes : 
  virtual public CORBA::Object
{
  public:
    virtual ~ImportAttributes();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ImportAttributes_ptr _ptr_type;
    typedef ImportAttributes_var _var_type;
    #endif

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

    static ImportAttributes_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong def_search_card() = 0;
    virtual CORBA::ULong max_search_card() = 0;
    virtual CORBA::ULong def_match_card() = 0;
    virtual CORBA::ULong max_match_card() = 0;
    virtual CORBA::ULong def_return_card() = 0;
    virtual CORBA::ULong max_return_card() = 0;
    virtual CORBA::ULong max_list() = 0;
    virtual CORBA::ULong def_hop_count() = 0;
    virtual CORBA::ULong max_hop_count() = 0;
    virtual FollowOption def_follow_policy() = 0;
    virtual FollowOption max_follow_policy() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ImportAttributes;

// Stub for interface ImportAttributes
class ImportAttributes_stub:
  virtual public ImportAttributes
{
  public:
    virtual ~ImportAttributes_stub();
    CORBA::ULong def_search_card();
    CORBA::ULong max_search_card();
    CORBA::ULong def_match_card();
    CORBA::ULong max_match_card();
    CORBA::ULong def_return_card();
    CORBA::ULong max_return_card();
    CORBA::ULong max_list();
    CORBA::ULong def_hop_count();
    CORBA::ULong max_hop_count();
    FollowOption def_follow_policy();
    FollowOption max_follow_policy();

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

class ImportAttributes_skel :
  virtual public StaticMethodDispatcher,
  virtual public ImportAttributes
{
  public:
    ImportAttributes_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~ImportAttributes_skel();
    ImportAttributes_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    ImportAttributes_ptr _this();

};

typedef char* Istring;
typedef CORBA::String_var Istring_var;
typedef CORBA::String_out Istring_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Istring;

typedef char* PropertyName;
typedef CORBA::String_var PropertyName_var;
typedef CORBA::String_out PropertyName_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyName;

typedef StringSequenceTmpl<CORBA::String_var> PropertyNameSeq;
#ifdef _WINDOWS
static PropertyNameSeq _dummy_PropertyNameSeq;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > PropertyNameSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > PropertyNameSeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyNameSeq;

typedef char* PolicyName;
typedef CORBA::String_var PolicyName_var;
typedef CORBA::String_out PolicyName_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PolicyName;

typedef CORBA::Any PolicyValue;
#ifdef _WINDOWS
static PolicyValue _dummy_PolicyValue;
#endif
typedef CORBA::Any_var PolicyValue_var;
typedef CORBA::Any_out PolicyValue_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PolicyValue;

struct Policy;
typedef TVarVar<Policy> Policy_var;
typedef TVarOut<Policy> Policy_out;


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

  PolicyName_var name;
  PolicyValue value;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Policy;

typedef char* ServiceTypeName;
typedef CORBA::String_var ServiceTypeName_var;
typedef CORBA::String_out ServiceTypeName_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ServiceTypeName;

typedef char* Constraint;
typedef CORBA::String_var Constraint_var;
typedef CORBA::String_out Constraint_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Constraint;

typedef SequenceTmpl<Policy,MICO_TID_DEF> PolicySeq;
#ifdef _WINDOWS
static PolicySeq _dummy_PolicySeq;
#endif
typedef TSeqVar<SequenceTmpl<Policy,MICO_TID_DEF> > PolicySeq_var;
typedef TSeqOut<SequenceTmpl<Policy,MICO_TID_DEF> > PolicySeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PolicySeq;

struct Offer;
typedef TVarVar<Offer> Offer_var;
typedef TVarOut<Offer> Offer_out;


typedef SequenceTmpl<Offer,MICO_TID_DEF> OfferSeq;
#ifdef _WINDOWS
static OfferSeq _dummy_OfferSeq;
#endif
typedef TSeqVar<SequenceTmpl<Offer,MICO_TID_DEF> > OfferSeq_var;
typedef TSeqOut<SequenceTmpl<Offer,MICO_TID_DEF> > OfferSeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_OfferSeq;

class OfferIterator;
typedef OfferIterator *OfferIterator_ptr;
typedef OfferIterator_ptr OfferIteratorRef;
typedef ObjVar<OfferIterator> OfferIterator_var;
typedef ObjOut<OfferIterator> OfferIterator_out;

typedef StringSequenceTmpl<CORBA::String_var> PolicyNameSeq;
#ifdef _WINDOWS
static PolicyNameSeq _dummy_PolicyNameSeq;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > PolicyNameSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > PolicyNameSeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PolicyNameSeq;

struct IllegalServiceType : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  IllegalServiceType();
  ~IllegalServiceType();
  IllegalServiceType( const IllegalServiceType& s );
  IllegalServiceType& operator=( const IllegalServiceType& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  IllegalServiceType();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  IllegalServiceType( const char* _m0 );

  #ifdef HAVE_STD_EH
  IllegalServiceType *operator->() { return this; }
  IllegalServiceType& operator*() { return *this; }
  operator IllegalServiceType*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static IllegalServiceType *_downcast( CORBA::Exception *ex );
  static const IllegalServiceType *_downcast( const CORBA::Exception *ex );
  ServiceTypeName_var type;
};

#ifdef HAVE_STD_EH
typedef IllegalServiceType IllegalServiceType_catch;
#else
typedef ExceptVar<IllegalServiceType> IllegalServiceType_var;
typedef TVarOut<IllegalServiceType> IllegalServiceType_out;
typedef IllegalServiceType_var IllegalServiceType_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_IllegalServiceType;

struct UnknownServiceType : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnknownServiceType();
  ~UnknownServiceType();
  UnknownServiceType( const UnknownServiceType& s );
  UnknownServiceType& operator=( const UnknownServiceType& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  UnknownServiceType();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  UnknownServiceType( const char* _m0 );

  #ifdef HAVE_STD_EH
  UnknownServiceType *operator->() { return this; }
  UnknownServiceType& operator*() { return *this; }
  operator UnknownServiceType*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnknownServiceType *_downcast( CORBA::Exception *ex );
  static const UnknownServiceType *_downcast( const CORBA::Exception *ex );
  ServiceTypeName_var type;
};

#ifdef HAVE_STD_EH
typedef UnknownServiceType UnknownServiceType_catch;
#else
typedef ExceptVar<UnknownServiceType> UnknownServiceType_var;
typedef TVarOut<UnknownServiceType> UnknownServiceType_out;
typedef UnknownServiceType_var UnknownServiceType_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnknownServiceType;

struct IllegalConstraint : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  IllegalConstraint();
  ~IllegalConstraint();
  IllegalConstraint( const IllegalConstraint& s );
  IllegalConstraint& operator=( const IllegalConstraint& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  IllegalConstraint();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  IllegalConstraint( const char* _m0 );

  #ifdef HAVE_STD_EH
  IllegalConstraint *operator->() { return this; }
  IllegalConstraint& operator*() { return *this; }
  operator IllegalConstraint*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static IllegalConstraint *_downcast( CORBA::Exception *ex );
  static const IllegalConstraint *_downcast( const CORBA::Exception *ex );
  Constraint_var constr;
};

#ifdef HAVE_STD_EH
typedef IllegalConstraint IllegalConstraint_catch;
#else
typedef ExceptVar<IllegalConstraint> IllegalConstraint_var;
typedef TVarOut<IllegalConstraint> IllegalConstraint_out;
typedef IllegalConstraint_var IllegalConstraint_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_IllegalConstraint;

struct IllegalPropertyName : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  IllegalPropertyName();
  ~IllegalPropertyName();
  IllegalPropertyName( const IllegalPropertyName& s );
  IllegalPropertyName& operator=( const IllegalPropertyName& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  IllegalPropertyName();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  IllegalPropertyName( const char* _m0 );

  #ifdef HAVE_STD_EH
  IllegalPropertyName *operator->() { return this; }
  IllegalPropertyName& operator*() { return *this; }
  operator IllegalPropertyName*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static IllegalPropertyName *_downcast( CORBA::Exception *ex );
  static const IllegalPropertyName *_downcast( const CORBA::Exception *ex );
  PropertyName_var name;
};

#ifdef HAVE_STD_EH
typedef IllegalPropertyName IllegalPropertyName_catch;
#else
typedef ExceptVar<IllegalPropertyName> IllegalPropertyName_var;
typedef TVarOut<IllegalPropertyName> IllegalPropertyName_out;
typedef IllegalPropertyName_var IllegalPropertyName_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_IllegalPropertyName;

struct DuplicatePropertyName : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePropertyName();
  ~DuplicatePropertyName();
  DuplicatePropertyName( const DuplicatePropertyName& s );
  DuplicatePropertyName& operator=( const DuplicatePropertyName& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePropertyName();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePropertyName( const char* _m0 );

  #ifdef HAVE_STD_EH
  DuplicatePropertyName *operator->() { return this; }
  DuplicatePropertyName& operator*() { return *this; }
  operator DuplicatePropertyName*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static DuplicatePropertyName *_downcast( CORBA::Exception *ex );
  static const DuplicatePropertyName *_downcast( const CORBA::Exception *ex );
  PropertyName_var name;
};

#ifdef HAVE_STD_EH
typedef DuplicatePropertyName DuplicatePropertyName_catch;
#else
typedef ExceptVar<DuplicatePropertyName> DuplicatePropertyName_var;
typedef TVarOut<DuplicatePropertyName> DuplicatePropertyName_out;
typedef DuplicatePropertyName_var DuplicatePropertyName_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_DuplicatePropertyName;

struct DuplicatePolicyName : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePolicyName();
  ~DuplicatePolicyName();
  DuplicatePolicyName( const DuplicatePolicyName& s );
  DuplicatePolicyName& operator=( const DuplicatePolicyName& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePolicyName();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  DuplicatePolicyName( const char* _m0 );

  #ifdef HAVE_STD_EH
  DuplicatePolicyName *operator->() { return this; }
  DuplicatePolicyName& operator*() { return *this; }
  operator DuplicatePolicyName*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static DuplicatePolicyName *_downcast( CORBA::Exception *ex );
  static const DuplicatePolicyName *_downcast( const CORBA::Exception *ex );
  PolicyName_var name;
};

#ifdef HAVE_STD_EH
typedef DuplicatePolicyName DuplicatePolicyName_catch;
#else
typedef ExceptVar<DuplicatePolicyName> DuplicatePolicyName_var;
typedef TVarOut<DuplicatePolicyName> DuplicatePolicyName_out;
typedef DuplicatePolicyName_var DuplicatePolicyName_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_DuplicatePolicyName;


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

class Lookup : 
  virtual public ::CosTrading::TraderComponents,
  virtual public ::CosTrading::SupportAttributes,
  virtual public ::CosTrading::ImportAttributes
{
  public:
    typedef ::CosTrading::TraderComponents _VCHACK__CosTrading__TraderComponents;
    typedef ::CosTrading::SupportAttributes _VCHACK__CosTrading__SupportAttributes;
    typedef ::CosTrading::ImportAttributes _VCHACK__CosTrading__ImportAttributes;
    virtual ~Lookup();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Lookup_ptr _ptr_type;
    typedef Lookup_var _var_type;
    #endif

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

    static Lookup_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    typedef char* Preference;
    typedef CORBA::String_var Preference_var;
    typedef CORBA::String_out Preference_out;

    static CORBA::TypeCodeConst _tc_Preference;

    enum HowManyProps {
      none = 0,
      some,
      all
    };

    typedef HowManyProps& HowManyProps_out;

    static CORBA::TypeCodeConst _tc_HowManyProps;

    class SpecifiedProps;
    typedef TVarVar<SpecifiedProps> SpecifiedProps_var;
    typedef TVarOut<SpecifiedProps> SpecifiedProps_out;


    class SpecifiedProps {
      public:
        #ifdef HAVE_TYPEDEF_OVERLOAD
        typedef SpecifiedProps_var _var_type;
        #endif
        HowManyProps _discriminator;

        struct __m {
          PropertyNameSeq prop_names;
        } _m;

      public:
        #ifdef HAVE_EXPLICIT_STRUCT_OPS
        SpecifiedProps();
        ~SpecifiedProps();
        SpecifiedProps( const SpecifiedProps& s );
        SpecifiedProps& operator=( const SpecifiedProps& s );
        #endif //HAVE_EXPLICIT_STRUCT_OPS


        void _d( HowManyProps _p );
        HowManyProps _d() const;

        void prop_names( const PropertyNameSeq& _p );
        const PropertyNameSeq& prop_names() const;
        PropertyNameSeq& prop_names();

        void _default();

    };

    static CORBA::TypeCodeConst _tc_SpecifiedProps;

    struct IllegalPreference : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      IllegalPreference();
      ~IllegalPreference();
      IllegalPreference( const IllegalPreference& s );
      IllegalPreference& operator=( const IllegalPreference& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      IllegalPreference();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      IllegalPreference( const char* _m0 );

      #ifdef HAVE_STD_EH
      IllegalPreference *operator->() { return this; }
      IllegalPreference& operator*() { return *this; }
      operator IllegalPreference*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static IllegalPreference *_downcast( CORBA::Exception *ex );
      static const IllegalPreference *_downcast( const CORBA::Exception *ex );
      Preference_var pref;
    };

    #ifdef HAVE_STD_EH
    typedef IllegalPreference IllegalPreference_catch;
    #else
    typedef ExceptVar<IllegalPreference> IllegalPreference_var;
    typedef TVarOut<IllegalPreference> IllegalPreference_out;
    typedef IllegalPreference_var IllegalPreference_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_IllegalPreference;

    struct IllegalPolicyName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      IllegalPolicyName();
      ~IllegalPolicyName();
      IllegalPolicyName( const IllegalPolicyName& s );
      IllegalPolicyName& operator=( const IllegalPolicyName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      IllegalPolicyName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      IllegalPolicyName( const char* _m0 );

      #ifdef HAVE_STD_EH
      IllegalPolicyName *operator->() { return this; }
      IllegalPolicyName& operator*() { return *this; }
      operator IllegalPolicyName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static IllegalPolicyName *_downcast( CORBA::Exception *ex );
      static const IllegalPolicyName *_downcast( const CORBA::Exception *ex );
      PolicyName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef IllegalPolicyName IllegalPolicyName_catch;
    #else
    typedef ExceptVar<IllegalPolicyName> IllegalPolicyName_var;
    typedef TVarOut<IllegalPolicyName> IllegalPolicyName_out;
    typedef IllegalPolicyName_var IllegalPolicyName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_IllegalPolicyName;

    struct PolicyTypeMismatch : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      PolicyTypeMismatch();
      ~PolicyTypeMismatch();
      PolicyTypeMismatch( const PolicyTypeMismatch& s );
      PolicyTypeMismatch& operator=( const PolicyTypeMismatch& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      PolicyTypeMismatch();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      PolicyTypeMismatch( const Policy& _m0 );

      #ifdef HAVE_STD_EH
      PolicyTypeMismatch *operator->() { return this; }
      PolicyTypeMismatch& operator*() { return *this; }
      operator PolicyTypeMismatch*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static PolicyTypeMismatch *_downcast( CORBA::Exception *ex );
      static const PolicyTypeMismatch *_downcast( const CORBA::Exception *ex );
      Policy the_policy;
    };

    #ifdef HAVE_STD_EH
    typedef PolicyTypeMismatch PolicyTypeMismatch_catch;
    #else
    typedef ExceptVar<PolicyTypeMismatch> PolicyTypeMismatch_var;
    typedef TVarOut<PolicyTypeMismatch> PolicyTypeMismatch_out;
    typedef PolicyTypeMismatch_var PolicyTypeMismatch_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_PolicyTypeMismatch;

    struct InvalidPolicyValue : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      InvalidPolicyValue();
      ~InvalidPolicyValue();
      InvalidPolicyValue( const InvalidPolicyValue& s );
      InvalidPolicyValue& operator=( const InvalidPolicyValue& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      InvalidPolicyValue();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      InvalidPolicyValue( const Policy& _m0 );

      #ifdef HAVE_STD_EH
      InvalidPolicyValue *operator->() { return this; }
      InvalidPolicyValue& operator*() { return *this; }
      operator InvalidPolicyValue*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InvalidPolicyValue *_downcast( CORBA::Exception *ex );
      static const InvalidPolicyValue *_downcast( const CORBA::Exception *ex );
      Policy the_policy;
    };

    #ifdef HAVE_STD_EH
    typedef InvalidPolicyValue InvalidPolicyValue_catch;
    #else
    typedef ExceptVar<InvalidPolicyValue> InvalidPolicyValue_var;
    typedef TVarOut<InvalidPolicyValue> InvalidPolicyValue_out;
    typedef InvalidPolicyValue_var InvalidPolicyValue_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_InvalidPolicyValue;

    virtual void query( const char* type, const char* constr, const char* pref, const PolicySeq& policies, const SpecifiedProps& desired_props, CORBA::ULong how_many, OfferSeq_out offers, OfferIterator_out offer_itr, PolicyNameSeq_out limits_applied ) = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Lookup;

// Stub for interface Lookup
class Lookup_stub:
  virtual public Lookup,
  virtual public ::CosTrading::TraderComponents_stub,
  virtual public ::CosTrading::SupportAttributes_stub,
  virtual public ::CosTrading::ImportAttributes_stub
{
  public:
    virtual ~Lookup_stub();
    void query( const char* type, const char* constr, const char* pref, const PolicySeq& policies, const SpecifiedProps& desired_props, CORBA::ULong how_many, OfferSeq_out offers, OfferIterator_out offer_itr, PolicyNameSeq_out limits_applied );

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

class Lookup_skel :
  virtual public StaticMethodDispatcher,
  virtual public Lookup
{
  public:
    Lookup_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Lookup_skel();
    Lookup_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Lookup_ptr _this();

};

struct Property;
typedef TVarVar<Property> Property_var;
typedef TVarOut<Property> Property_out;


typedef SequenceTmpl<Property,MICO_TID_DEF> PropertySeq;
#ifdef _WINDOWS
static PropertySeq _dummy_PropertySeq;
#endif
typedef TSeqVar<SequenceTmpl<Property,MICO_TID_DEF> > PropertySeq_var;
typedef TSeqOut<SequenceTmpl<Property,MICO_TID_DEF> > PropertySeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertySeq;

typedef char* OfferId;
typedef CORBA::String_var OfferId_var;
typedef CORBA::String_out OfferId_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_OfferId;

typedef char* LinkName;
typedef CORBA::String_var LinkName_var;
typedef CORBA::String_out LinkName_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_LinkName;

typedef StringSequenceTmpl<CORBA::String_var> LinkNameSeq;
#ifdef _WINDOWS
static LinkNameSeq _dummy_LinkNameSeq;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > LinkNameSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > LinkNameSeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_LinkNameSeq;

typedef LinkNameSeq TraderName;
#ifdef _WINDOWS
static TraderName _dummy_TraderName;
#endif
typedef TSeqVar<LinkNameSeq > TraderName_var;
typedef TSeqOut<LinkNameSeq > TraderName_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_TraderName;

typedef CORBA::Any PropertyValue;
#ifdef _WINDOWS
static PropertyValue _dummy_PropertyValue;
#endif
typedef CORBA::Any_var PropertyValue_var;
typedef CORBA::Any_out PropertyValue_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyValue;

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

  PropertyName_var name;
  PropertyValue value;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Property;

struct PropertyTypeMismatch : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  PropertyTypeMismatch();
  ~PropertyTypeMismatch();
  PropertyTypeMismatch( const PropertyTypeMismatch& s );
  PropertyTypeMismatch& operator=( const PropertyTypeMismatch& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  PropertyTypeMismatch();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  PropertyTypeMismatch( const char* _m0, const Property& _m1 );

  #ifdef HAVE_STD_EH
  PropertyTypeMismatch *operator->() { return this; }
  PropertyTypeMismatch& operator*() { return *this; }
  operator PropertyTypeMismatch*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static PropertyTypeMismatch *_downcast( CORBA::Exception *ex );
  static const PropertyTypeMismatch *_downcast( const CORBA::Exception *ex );
  ServiceTypeName_var type;
  Property prop;
};

#ifdef HAVE_STD_EH
typedef PropertyTypeMismatch PropertyTypeMismatch_catch;
#else
typedef ExceptVar<PropertyTypeMismatch> PropertyTypeMismatch_var;
typedef TVarOut<PropertyTypeMismatch> PropertyTypeMismatch_out;
typedef PropertyTypeMismatch_var PropertyTypeMismatch_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_PropertyTypeMismatch;

struct ReadonlyDynamicProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  ReadonlyDynamicProperty();
  ~ReadonlyDynamicProperty();
  ReadonlyDynamicProperty( const ReadonlyDynamicProperty& s );
  ReadonlyDynamicProperty& operator=( const ReadonlyDynamicProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  ReadonlyDynamicProperty();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  ReadonlyDynamicProperty( const char* _m0, const char* _m1 );

  #ifdef HAVE_STD_EH
  ReadonlyDynamicProperty *operator->() { return this; }
  ReadonlyDynamicProperty& operator*() { return *this; }
  operator ReadonlyDynamicProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ReadonlyDynamicProperty *_downcast( CORBA::Exception *ex );
  static const ReadonlyDynamicProperty *_downcast( const CORBA::Exception *ex );
  ServiceTypeName_var type;
  PropertyName_var name;
};

#ifdef HAVE_STD_EH
typedef ReadonlyDynamicProperty ReadonlyDynamicProperty_catch;
#else
typedef ExceptVar<ReadonlyDynamicProperty> ReadonlyDynamicProperty_var;
typedef TVarOut<ReadonlyDynamicProperty> ReadonlyDynamicProperty_out;
typedef ReadonlyDynamicProperty_var ReadonlyDynamicProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_ReadonlyDynamicProperty;

struct MissingMandatoryProperty : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  MissingMandatoryProperty();
  ~MissingMandatoryProperty();
  MissingMandatoryProperty( const MissingMandatoryProperty& s );
  MissingMandatoryProperty& operator=( const MissingMandatoryProperty& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  MissingMandatoryProperty();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  MissingMandatoryProperty( const char* _m0, const char* _m1 );

  #ifdef HAVE_STD_EH
  MissingMandatoryProperty *operator->() { return this; }
  MissingMandatoryProperty& operator*() { return *this; }
  operator MissingMandatoryProperty*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static MissingMandatoryProperty *_downcast( CORBA::Exception *ex );
  static const MissingMandatoryProperty *_downcast( const CORBA::Exception *ex );
  ServiceTypeName_var type;
  PropertyName_var name;
};

#ifdef HAVE_STD_EH
typedef MissingMandatoryProperty MissingMandatoryProperty_catch;
#else
typedef ExceptVar<MissingMandatoryProperty> MissingMandatoryProperty_var;
typedef TVarOut<MissingMandatoryProperty> MissingMandatoryProperty_out;
typedef MissingMandatoryProperty_var MissingMandatoryProperty_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_MissingMandatoryProperty;

struct IllegalOfferId : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  IllegalOfferId();
  ~IllegalOfferId();
  IllegalOfferId( const IllegalOfferId& s );
  IllegalOfferId& operator=( const IllegalOfferId& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  IllegalOfferId();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  IllegalOfferId( const char* _m0 );

  #ifdef HAVE_STD_EH
  IllegalOfferId *operator->() { return this; }
  IllegalOfferId& operator*() { return *this; }
  operator IllegalOfferId*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static IllegalOfferId *_downcast( CORBA::Exception *ex );
  static const IllegalOfferId *_downcast( const CORBA::Exception *ex );
  OfferId_var id;
};

#ifdef HAVE_STD_EH
typedef IllegalOfferId IllegalOfferId_catch;
#else
typedef ExceptVar<IllegalOfferId> IllegalOfferId_var;
typedef TVarOut<IllegalOfferId> IllegalOfferId_out;
typedef IllegalOfferId_var IllegalOfferId_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_IllegalOfferId;

struct UnknownOfferId : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnknownOfferId();
  ~UnknownOfferId();
  UnknownOfferId( const UnknownOfferId& s );
  UnknownOfferId& operator=( const UnknownOfferId& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  UnknownOfferId();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  UnknownOfferId( const char* _m0 );

  #ifdef HAVE_STD_EH
  UnknownOfferId *operator->() { return this; }
  UnknownOfferId& operator*() { return *this; }
  operator UnknownOfferId*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnknownOfferId *_downcast( CORBA::Exception *ex );
  static const UnknownOfferId *_downcast( const CORBA::Exception *ex );
  OfferId_var id;
};

#ifdef HAVE_STD_EH
typedef UnknownOfferId UnknownOfferId_catch;
#else
typedef ExceptVar<UnknownOfferId> UnknownOfferId_var;
typedef TVarOut<UnknownOfferId> UnknownOfferId_out;
typedef UnknownOfferId_var UnknownOfferId_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnknownOfferId;

struct NotImplemented : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  NotImplemented();
  ~NotImplemented();
  NotImplemented( const NotImplemented& s );
  NotImplemented& operator=( const NotImplemented& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  NotImplemented *operator->() { return this; }
  NotImplemented& operator*() { return *this; }
  operator NotImplemented*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static NotImplemented *_downcast( CORBA::Exception *ex );
  static const NotImplemented *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef NotImplemented NotImplemented_catch;
#else
typedef ExceptVar<NotImplemented> NotImplemented_var;
typedef TVarOut<NotImplemented> NotImplemented_out;
typedef NotImplemented_var NotImplemented_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_NotImplemented;


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

class Register : 
  virtual public ::CosTrading::TraderComponents,
  virtual public ::CosTrading::SupportAttributes
{
  public:
    typedef ::CosTrading::TraderComponents _VCHACK__CosTrading__TraderComponents;
    typedef ::CosTrading::SupportAttributes _VCHACK__CosTrading__SupportAttributes;
    virtual ~Register();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Register_ptr _ptr_type;
    typedef Register_var _var_type;
    #endif

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

    static Register_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct OfferInfo;
    typedef TVarVar<OfferInfo> OfferInfo_var;
    typedef TVarOut<OfferInfo> OfferInfo_out;


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

      CORBA::Object_var reference;
      ServiceTypeName_var type;
      PropertySeq properties;
    };

    static CORBA::TypeCodeConst _tc_OfferInfo;

    struct InvalidObjectRef : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      InvalidObjectRef();
      ~InvalidObjectRef();
      InvalidObjectRef( const InvalidObjectRef& s );
      InvalidObjectRef& operator=( const InvalidObjectRef& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      InvalidObjectRef();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      InvalidObjectRef( CORBA::Object_ptr _m0 );

      #ifdef HAVE_STD_EH
      InvalidObjectRef *operator->() { return this; }
      InvalidObjectRef& operator*() { return *this; }
      operator InvalidObjectRef*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InvalidObjectRef *_downcast( CORBA::Exception *ex );
      static const InvalidObjectRef *_downcast( const CORBA::Exception *ex );
      CORBA::Object_var ref;
    };

    #ifdef HAVE_STD_EH
    typedef InvalidObjectRef InvalidObjectRef_catch;
    #else
    typedef ExceptVar<InvalidObjectRef> InvalidObjectRef_var;
    typedef TVarOut<InvalidObjectRef> InvalidObjectRef_out;
    typedef InvalidObjectRef_var InvalidObjectRef_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_InvalidObjectRef;

    struct UnknownPropertyName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      UnknownPropertyName();
      ~UnknownPropertyName();
      UnknownPropertyName( const UnknownPropertyName& s );
      UnknownPropertyName& operator=( const UnknownPropertyName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      UnknownPropertyName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      UnknownPropertyName( const char* _m0 );

      #ifdef HAVE_STD_EH
      UnknownPropertyName *operator->() { return this; }
      UnknownPropertyName& operator*() { return *this; }
      operator UnknownPropertyName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static UnknownPropertyName *_downcast( CORBA::Exception *ex );
      static const UnknownPropertyName *_downcast( const CORBA::Exception *ex );
      PropertyName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef UnknownPropertyName UnknownPropertyName_catch;
    #else
    typedef ExceptVar<UnknownPropertyName> UnknownPropertyName_var;
    typedef TVarOut<UnknownPropertyName> UnknownPropertyName_out;
    typedef UnknownPropertyName_var UnknownPropertyName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_UnknownPropertyName;

    struct InterfaceTypeMismatch : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      InterfaceTypeMismatch();
      ~InterfaceTypeMismatch();
      InterfaceTypeMismatch( const InterfaceTypeMismatch& s );
      InterfaceTypeMismatch& operator=( const InterfaceTypeMismatch& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      InterfaceTypeMismatch();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      InterfaceTypeMismatch( const char* _m0, CORBA::Object_ptr _m1 );

      #ifdef HAVE_STD_EH
      InterfaceTypeMismatch *operator->() { return this; }
      InterfaceTypeMismatch& operator*() { return *this; }
      operator InterfaceTypeMismatch*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InterfaceTypeMismatch *_downcast( CORBA::Exception *ex );
      static const InterfaceTypeMismatch *_downcast( const CORBA::Exception *ex );
      ServiceTypeName_var type;
      CORBA::Object_var reference;
    };

    #ifdef HAVE_STD_EH
    typedef InterfaceTypeMismatch InterfaceTypeMismatch_catch;
    #else
    typedef ExceptVar<InterfaceTypeMismatch> InterfaceTypeMismatch_var;
    typedef TVarOut<InterfaceTypeMismatch> InterfaceTypeMismatch_out;
    typedef InterfaceTypeMismatch_var InterfaceTypeMismatch_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_InterfaceTypeMismatch;

    struct ProxyOfferId : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      ProxyOfferId();
      ~ProxyOfferId();
      ProxyOfferId( const ProxyOfferId& s );
      ProxyOfferId& operator=( const ProxyOfferId& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      ProxyOfferId();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      ProxyOfferId( const char* _m0 );

      #ifdef HAVE_STD_EH
      ProxyOfferId *operator->() { return this; }
      ProxyOfferId& operator*() { return *this; }
      operator ProxyOfferId*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ProxyOfferId *_downcast( CORBA::Exception *ex );
      static const ProxyOfferId *_downcast( const CORBA::Exception *ex );
      OfferId_var id;
    };

    #ifdef HAVE_STD_EH
    typedef ProxyOfferId ProxyOfferId_catch;
    #else
    typedef ExceptVar<ProxyOfferId> ProxyOfferId_var;
    typedef TVarOut<ProxyOfferId> ProxyOfferId_out;
    typedef ProxyOfferId_var ProxyOfferId_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_ProxyOfferId;

    struct MandatoryProperty : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      MandatoryProperty();
      ~MandatoryProperty();
      MandatoryProperty( const MandatoryProperty& s );
      MandatoryProperty& operator=( const MandatoryProperty& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      MandatoryProperty();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      MandatoryProperty( const char* _m0, const char* _m1 );

      #ifdef HAVE_STD_EH
      MandatoryProperty *operator->() { return this; }
      MandatoryProperty& operator*() { return *this; }
      operator MandatoryProperty*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static MandatoryProperty *_downcast( CORBA::Exception *ex );
      static const MandatoryProperty *_downcast( const CORBA::Exception *ex );
      ServiceTypeName_var type;
      PropertyName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef MandatoryProperty MandatoryProperty_catch;
    #else
    typedef ExceptVar<MandatoryProperty> MandatoryProperty_var;
    typedef TVarOut<MandatoryProperty> MandatoryProperty_out;
    typedef MandatoryProperty_var MandatoryProperty_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_MandatoryProperty;

    struct ReadonlyProperty : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      ReadonlyProperty();
      ~ReadonlyProperty();
      ReadonlyProperty( const ReadonlyProperty& s );
      ReadonlyProperty& operator=( const ReadonlyProperty& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      ReadonlyProperty();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      ReadonlyProperty( const char* _m0, const char* _m1 );

      #ifdef HAVE_STD_EH
      ReadonlyProperty *operator->() { return this; }
      ReadonlyProperty& operator*() { return *this; }
      operator ReadonlyProperty*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ReadonlyProperty *_downcast( CORBA::Exception *ex );
      static const ReadonlyProperty *_downcast( const CORBA::Exception *ex );
      ServiceTypeName_var type;
      PropertyName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef ReadonlyProperty ReadonlyProperty_catch;
    #else
    typedef ExceptVar<ReadonlyProperty> ReadonlyProperty_var;
    typedef TVarOut<ReadonlyProperty> ReadonlyProperty_out;
    typedef ReadonlyProperty_var ReadonlyProperty_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_ReadonlyProperty;

    struct NoMatchingOffers : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      NoMatchingOffers();
      ~NoMatchingOffers();
      NoMatchingOffers( const NoMatchingOffers& s );
      NoMatchingOffers& operator=( const NoMatchingOffers& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      NoMatchingOffers();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      NoMatchingOffers( const char* _m0 );

      #ifdef HAVE_STD_EH
      NoMatchingOffers *operator->() { return this; }
      NoMatchingOffers& operator*() { return *this; }
      operator NoMatchingOffers*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static NoMatchingOffers *_downcast( CORBA::Exception *ex );
      static const NoMatchingOffers *_downcast( const CORBA::Exception *ex );
      Constraint_var constr;
    };

    #ifdef HAVE_STD_EH
    typedef NoMatchingOffers NoMatchingOffers_catch;
    #else
    typedef ExceptVar<NoMatchingOffers> NoMatchingOffers_var;
    typedef TVarOut<NoMatchingOffers> NoMatchingOffers_out;
    typedef NoMatchingOffers_var NoMatchingOffers_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_NoMatchingOffers;

    struct IllegalTraderName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      IllegalTraderName();
      ~IllegalTraderName();
      IllegalTraderName( const IllegalTraderName& s );
      IllegalTraderName& operator=( const IllegalTraderName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      IllegalTraderName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      IllegalTraderName( const TraderName& _m0 );

      #ifdef HAVE_STD_EH
      IllegalTraderName *operator->() { return this; }
      IllegalTraderName& operator*() { return *this; }
      operator IllegalTraderName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static IllegalTraderName *_downcast( CORBA::Exception *ex );
      static const IllegalTraderName *_downcast( const CORBA::Exception *ex );
      TraderName name;
    };

    #ifdef HAVE_STD_EH
    typedef IllegalTraderName IllegalTraderName_catch;
    #else
    typedef ExceptVar<IllegalTraderName> IllegalTraderName_var;
    typedef TVarOut<IllegalTraderName> IllegalTraderName_out;
    typedef IllegalTraderName_var IllegalTraderName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_IllegalTraderName;

    struct UnknownTraderName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      UnknownTraderName();
      ~UnknownTraderName();
      UnknownTraderName( const UnknownTraderName& s );
      UnknownTraderName& operator=( const UnknownTraderName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      UnknownTraderName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      UnknownTraderName( const TraderName& _m0 );

      #ifdef HAVE_STD_EH
      UnknownTraderName *operator->() { return this; }
      UnknownTraderName& operator*() { return *this; }
      operator UnknownTraderName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static UnknownTraderName *_downcast( CORBA::Exception *ex );
      static const UnknownTraderName *_downcast( const CORBA::Exception *ex );
      TraderName name;
    };

    #ifdef HAVE_STD_EH
    typedef UnknownTraderName UnknownTraderName_catch;
    #else
    typedef ExceptVar<UnknownTraderName> UnknownTraderName_var;
    typedef TVarOut<UnknownTraderName> UnknownTraderName_out;
    typedef UnknownTraderName_var UnknownTraderName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_UnknownTraderName;

    struct RegisterNotSupported : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      RegisterNotSupported();
      ~RegisterNotSupported();
      RegisterNotSupported( const RegisterNotSupported& s );
      RegisterNotSupported& operator=( const RegisterNotSupported& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      RegisterNotSupported();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      RegisterNotSupported( const TraderName& _m0 );

      #ifdef HAVE_STD_EH
      RegisterNotSupported *operator->() { return this; }
      RegisterNotSupported& operator*() { return *this; }
      operator RegisterNotSupported*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static RegisterNotSupported *_downcast( CORBA::Exception *ex );
      static const RegisterNotSupported *_downcast( const CORBA::Exception *ex );
      TraderName name;
    };

    #ifdef HAVE_STD_EH
    typedef RegisterNotSupported RegisterNotSupported_catch;
    #else
    typedef ExceptVar<RegisterNotSupported> RegisterNotSupported_var;
    typedef TVarOut<RegisterNotSupported> RegisterNotSupported_out;
    typedef RegisterNotSupported_var RegisterNotSupported_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_RegisterNotSupported;

    virtual char* _cxx_export( CORBA::Object_ptr reference, const char* type, const PropertySeq& properties ) = 0;
    virtual void withdraw( const char* id ) = 0;
    virtual OfferInfo* describe( const char* id ) = 0;
    virtual void modify( const char* id, const PropertyNameSeq& del_list, const PropertySeq& modify_list ) = 0;
    virtual void withdraw_using_constraint( const char* type, const char* constr ) = 0;
    virtual Register_ptr resolve( const TraderName& name ) = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Register;

// Stub for interface Register
class Register_stub:
  virtual public Register,
  virtual public ::CosTrading::TraderComponents_stub,
  virtual public ::CosTrading::SupportAttributes_stub
{
  public:
    virtual ~Register_stub();
    char* _cxx_export( CORBA::Object_ptr reference, const char* type, const PropertySeq& properties );
    void withdraw( const char* id );
    OfferInfo* describe( const char* id );
    void modify( const char* id, const PropertyNameSeq& del_list, const PropertySeq& modify_list );
    void withdraw_using_constraint( const char* type, const char* constr );
    Register_ptr resolve( const TraderName& name );

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

class Register_skel :
  virtual public StaticMethodDispatcher,
  virtual public Register
{
  public:
    Register_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Register_skel();
    Register_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Register_ptr _this();

};

class LinkAttributes;
typedef LinkAttributes *LinkAttributes_ptr;
typedef LinkAttributes_ptr LinkAttributesRef;
typedef ObjVar<LinkAttributes> LinkAttributes_var;
typedef ObjOut<LinkAttributes> LinkAttributes_out;


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

class LinkAttributes : 
  virtual public CORBA::Object
{
  public:
    virtual ~LinkAttributes();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef LinkAttributes_ptr _ptr_type;
    typedef LinkAttributes_var _var_type;
    #endif

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

    static LinkAttributes_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual FollowOption max_link_follow_policy() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_LinkAttributes;

// Stub for interface LinkAttributes
class LinkAttributes_stub:
  virtual public LinkAttributes
{
  public:
    virtual ~LinkAttributes_stub();
    FollowOption max_link_follow_policy();

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

class LinkAttributes_skel :
  virtual public StaticMethodDispatcher,
  virtual public LinkAttributes
{
  public:
    LinkAttributes_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~LinkAttributes_skel();
    LinkAttributes_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    LinkAttributes_ptr _this();

};

struct InvalidLookupRef : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  InvalidLookupRef();
  ~InvalidLookupRef();
  InvalidLookupRef( const InvalidLookupRef& s );
  InvalidLookupRef& operator=( const InvalidLookupRef& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  #ifndef HAVE_EXPLICIT_STRUCT_OPS
  InvalidLookupRef();
  #endif //HAVE_EXPLICIT_STRUCT_OPS
  InvalidLookupRef( Lookup_ptr _m0 );

  #ifdef HAVE_STD_EH
  InvalidLookupRef *operator->() { return this; }
  InvalidLookupRef& operator*() { return *this; }
  operator InvalidLookupRef*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static InvalidLookupRef *_downcast( CORBA::Exception *ex );
  static const InvalidLookupRef *_downcast( const CORBA::Exception *ex );
  Lookup_var target;
};

#ifdef HAVE_STD_EH
typedef InvalidLookupRef InvalidLookupRef_catch;
#else
typedef ExceptVar<InvalidLookupRef> InvalidLookupRef_var;
typedef TVarOut<InvalidLookupRef> InvalidLookupRef_out;
typedef InvalidLookupRef_var InvalidLookupRef_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_InvalidLookupRef;


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

class Link : 
  virtual public ::CosTrading::TraderComponents,
  virtual public ::CosTrading::SupportAttributes,
  virtual public ::CosTrading::LinkAttributes
{
  public:
    typedef ::CosTrading::TraderComponents _VCHACK__CosTrading__TraderComponents;
    typedef ::CosTrading::SupportAttributes _VCHACK__CosTrading__SupportAttributes;
    typedef ::CosTrading::LinkAttributes _VCHACK__CosTrading__LinkAttributes;
    virtual ~Link();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Link_ptr _ptr_type;
    typedef Link_var _var_type;
    #endif

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

    static Link_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct LinkInfo;
    typedef TVarVar<LinkInfo> LinkInfo_var;
    typedef TVarOut<LinkInfo> LinkInfo_out;


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

      Lookup_var target;
      Register_var target_reg;
      FollowOption def_pass_on_follow_rule;
      FollowOption limiting_follow_rule;
    };

    static CORBA::TypeCodeConst _tc_LinkInfo;

    struct IllegalLinkName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      IllegalLinkName();
      ~IllegalLinkName();
      IllegalLinkName( const IllegalLinkName& s );
      IllegalLinkName& operator=( const IllegalLinkName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      IllegalLinkName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      IllegalLinkName( const char* _m0 );

      #ifdef HAVE_STD_EH
      IllegalLinkName *operator->() { return this; }
      IllegalLinkName& operator*() { return *this; }
      operator IllegalLinkName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static IllegalLinkName *_downcast( CORBA::Exception *ex );
      static const IllegalLinkName *_downcast( const CORBA::Exception *ex );
      LinkName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef IllegalLinkName IllegalLinkName_catch;
    #else
    typedef ExceptVar<IllegalLinkName> IllegalLinkName_var;
    typedef TVarOut<IllegalLinkName> IllegalLinkName_out;
    typedef IllegalLinkName_var IllegalLinkName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_IllegalLinkName;

    struct UnknownLinkName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      UnknownLinkName();
      ~UnknownLinkName();
      UnknownLinkName( const UnknownLinkName& s );
      UnknownLinkName& operator=( const UnknownLinkName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      UnknownLinkName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      UnknownLinkName( const char* _m0 );

      #ifdef HAVE_STD_EH
      UnknownLinkName *operator->() { return this; }
      UnknownLinkName& operator*() { return *this; }
      operator UnknownLinkName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static UnknownLinkName *_downcast( CORBA::Exception *ex );
      static const UnknownLinkName *_downcast( const CORBA::Exception *ex );
      LinkName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef UnknownLinkName UnknownLinkName_catch;
    #else
    typedef ExceptVar<UnknownLinkName> UnknownLinkName_var;
    typedef TVarOut<UnknownLinkName> UnknownLinkName_out;
    typedef UnknownLinkName_var UnknownLinkName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_UnknownLinkName;

    struct DuplicateLinkName : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      DuplicateLinkName();
      ~DuplicateLinkName();
      DuplicateLinkName( const DuplicateLinkName& s );
      DuplicateLinkName& operator=( const DuplicateLinkName& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      DuplicateLinkName();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      DuplicateLinkName( const char* _m0 );

      #ifdef HAVE_STD_EH
      DuplicateLinkName *operator->() { return this; }
      DuplicateLinkName& operator*() { return *this; }
      operator DuplicateLinkName*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static DuplicateLinkName *_downcast( CORBA::Exception *ex );
      static const DuplicateLinkName *_downcast( const CORBA::Exception *ex );
      LinkName_var name;
    };

    #ifdef HAVE_STD_EH
    typedef DuplicateLinkName DuplicateLinkName_catch;
    #else
    typedef ExceptVar<DuplicateLinkName> DuplicateLinkName_var;
    typedef TVarOut<DuplicateLinkName> DuplicateLinkName_out;
    typedef DuplicateLinkName_var DuplicateLinkName_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_DuplicateLinkName;

    struct DefaultFollowTooPermissive : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      DefaultFollowTooPermissive();
      ~DefaultFollowTooPermissive();
      DefaultFollowTooPermissive( const DefaultFollowTooPermissive& s );
      DefaultFollowTooPermissive& operator=( const DefaultFollowTooPermissive& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      DefaultFollowTooPermissive();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      DefaultFollowTooPermissive( FollowOption _m0, FollowOption _m1 );

      #ifdef HAVE_STD_EH
      DefaultFollowTooPermissive *operator->() { return this; }
      DefaultFollowTooPermissive& operator*() { return *this; }
      operator DefaultFollowTooPermissive*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static DefaultFollowTooPermissive *_downcast( CORBA::Exception *ex );
      static const DefaultFollowTooPermissive *_downcast( const CORBA::Exception *ex );
      FollowOption def_pass_on_follow_rule;
      FollowOption limiting_follow_rule;
    };

    #ifdef HAVE_STD_EH
    typedef DefaultFollowTooPermissive DefaultFollowTooPermissive_catch;
    #else
    typedef ExceptVar<DefaultFollowTooPermissive> DefaultFollowTooPermissive_var;
    typedef TVarOut<DefaultFollowTooPermissive> DefaultFollowTooPermissive_out;
    typedef DefaultFollowTooPermissive_var DefaultFollowTooPermissive_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_DefaultFollowTooPermissive;

    struct LimitingFollowTooPermissive : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      LimitingFollowTooPermissive();
      ~LimitingFollowTooPermissive();
      LimitingFollowTooPermissive( const LimitingFollowTooPermissive& s );
      LimitingFollowTooPermissive& operator=( const LimitingFollowTooPermissive& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      LimitingFollowTooPermissive();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      LimitingFollowTooPermissive( FollowOption _m0, FollowOption _m1 );

      #ifdef HAVE_STD_EH
      LimitingFollowTooPermissive *operator->() { return this; }
      LimitingFollowTooPermissive& operator*() { return *this; }
      operator LimitingFollowTooPermissive*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static LimitingFollowTooPermissive *_downcast( CORBA::Exception *ex );
      static const LimitingFollowTooPermissive *_downcast( const CORBA::Exception *ex );
      FollowOption limiting_follow_rule;
      FollowOption max_link_follow_policy;
    };

    #ifdef HAVE_STD_EH
    typedef LimitingFollowTooPermissive LimitingFollowTooPermissive_catch;
    #else
    typedef ExceptVar<LimitingFollowTooPermissive> LimitingFollowTooPermissive_var;
    typedef TVarOut<LimitingFollowTooPermissive> LimitingFollowTooPermissive_out;
    typedef LimitingFollowTooPermissive_var LimitingFollowTooPermissive_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_LimitingFollowTooPermissive;

    virtual void add_link( const char* name, Lookup_ptr target, FollowOption def_pass_on_follow_rule, FollowOption limiting_follow_rule ) = 0;
    virtual void remove_link( const char* name ) = 0;
    virtual LinkInfo* describe_link( const char* name ) = 0;
    virtual LinkNameSeq* list_links() = 0;
    virtual void modify_link( const char* name, FollowOption def_pass_on_follow_rule, FollowOption limiting_follow_rule ) = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Link;

// Stub for interface Link
class Link_stub:
  virtual public Link,
  virtual public ::CosTrading::TraderComponents_stub,
  virtual public ::CosTrading::SupportAttributes_stub,
  virtual public ::CosTrading::LinkAttributes_stub
{
  public:
    virtual ~Link_stub();
    void add_link( const char* name, Lookup_ptr target, FollowOption def_pass_on_follow_rule, FollowOption limiting_follow_rule );
    void remove_link( const char* name );
    LinkInfo* describe_link( const char* name );
    LinkNameSeq* list_links();
    void modify_link( const char* name, FollowOption def_pass_on_follow_rule, FollowOption limiting_follow_rule );

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

class Link_skel :
  virtual public StaticMethodDispatcher,
  virtual public Link
{
  public:
    Link_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Link_skel();
    Link_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Link_ptr _this();

};


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

class Proxy : 
  virtual public ::CosTrading::TraderComponents,
  virtual public ::CosTrading::SupportAttributes
{
  public:
    typedef ::CosTrading::TraderComponents _VCHACK__CosTrading__TraderComponents;
    typedef ::CosTrading::SupportAttributes _VCHACK__CosTrading__SupportAttributes;
    virtual ~Proxy();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Proxy_ptr _ptr_type;
    typedef Proxy_var _var_type;
    #endif

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

    static Proxy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    typedef char* ConstraintRecipe;
    typedef CORBA::String_var ConstraintRecipe_var;
    typedef CORBA::String_out ConstraintRecipe_out;

    static CORBA::TypeCodeConst _tc_ConstraintRecipe;

    struct ProxyInfo;
    typedef TVarVar<ProxyInfo> ProxyInfo_var;
    typedef TVarOut<ProxyInfo> ProxyInfo_out;


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

      ServiceTypeName_var type;
      Lookup_var target;
      PropertySeq properties;
      CORBA::Boolean if_match_all;
      ConstraintRecipe_var recipe;
      PolicySeq policies_to_pass_on;
    };

    static CORBA::TypeCodeConst _tc_ProxyInfo;

    struct IllegalRecipe : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      IllegalRecipe();
      ~IllegalRecipe();
      IllegalRecipe( const IllegalRecipe& s );
      IllegalRecipe& operator=( const IllegalRecipe& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      IllegalRecipe();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      IllegalRecipe( const char* _m0 );

      #ifdef HAVE_STD_EH
      IllegalRecipe *operator->() { return this; }
      IllegalRecipe& operator*() { return *this; }
      operator IllegalRecipe*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static IllegalRecipe *_downcast( CORBA::Exception *ex );
      static const IllegalRecipe *_downcast( const CORBA::Exception *ex );
      ConstraintRecipe_var recipe;
    };

    #ifdef HAVE_STD_EH
    typedef IllegalRecipe IllegalRecipe_catch;
    #else
    typedef ExceptVar<IllegalRecipe> IllegalRecipe_var;
    typedef TVarOut<IllegalRecipe> IllegalRecipe_out;
    typedef IllegalRecipe_var IllegalRecipe_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_IllegalRecipe;

    struct NotProxyOfferId : public CORBA::UserException {
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      NotProxyOfferId();
      ~NotProxyOfferId();
      NotProxyOfferId( const NotProxyOfferId& s );
      NotProxyOfferId& operator=( const NotProxyOfferId& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      #ifndef HAVE_EXPLICIT_STRUCT_OPS
      NotProxyOfferId();
      #endif //HAVE_EXPLICIT_STRUCT_OPS
      NotProxyOfferId( const char* _m0 );

      #ifdef HAVE_STD_EH
      NotProxyOfferId *operator->() { return this; }
      NotProxyOfferId& operator*() { return *this; }
      operator NotProxyOfferId*() { return this; }
      #endif // HAVE_STD_EH

      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static NotProxyOfferId *_downcast( CORBA::Exception *ex );
      static const NotProxyOfferId *_downcast( const CORBA::Exception *ex );
      OfferId_var id;
    };

    #ifdef HAVE_STD_EH
    typedef NotProxyOfferId NotProxyOfferId_catch;
    #else
    typedef ExceptVar<NotProxyOfferId> NotProxyOfferId_var;
    typedef TVarOut<NotProxyOfferId> NotProxyOfferId_out;
    typedef NotProxyOfferId_var NotProxyOfferId_catch;
    #endif // HAVE_STD_EH

    static CORBA::TypeCodeConst _tc_NotProxyOfferId;

    virtual char* export_proxy( Lookup_ptr target, const char* type, const PropertySeq& properties, CORBA::Boolean if_match_all, const char* recipe, const PolicySeq& policies_to_pass_on ) = 0;
    virtual void withdraw_proxy( const char* id ) = 0;
    virtual ProxyInfo* describe_proxy( const char* id ) = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Proxy;

// Stub for interface Proxy
class Proxy_stub:
  virtual public Proxy,
  virtual public ::CosTrading::TraderComponents_stub,
  virtual public ::CosTrading::SupportAttributes_stub
{
  public:
    virtual ~Proxy_stub();
    char* export_proxy( Lookup_ptr target, const char* type, const PropertySeq& properties, CORBA::Boolean if_match_all, const char* recipe, const PolicySeq& policies_to_pass_on );
    void withdraw_proxy( const char* id );
    ProxyInfo* describe_proxy( const char* id );

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

class Proxy_skel :
  virtual public StaticMethodDispatcher,
  virtual public Proxy
{
  public:
    Proxy_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Proxy_skel();
    Proxy_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Proxy_ptr _this();

};

typedef StringSequenceTmpl<CORBA::String_var> OfferIdSeq;
#ifdef _WINDOWS
static OfferIdSeq _dummy_OfferIdSeq;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > OfferIdSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > OfferIdSeq_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_OfferIdSeq;

class OfferIdIterator;
typedef OfferIdIterator *OfferIdIterator_ptr;
typedef OfferIdIterator_ptr OfferIdIteratorRef;
typedef ObjVar<OfferIdIterator> OfferIdIterator_var;
typedef ObjOut<OfferIdIterator> OfferIdIterator_out;


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

class Admin : 
  virtual public ::CosTrading::TraderComponents,
  virtual public ::CosTrading::SupportAttributes,
  virtual public ::CosTrading::ImportAttributes,
  virtual public ::CosTrading::LinkAttributes
{
  public:
    typedef ::CosTrading::TraderComponents _VCHACK__CosTrading__TraderComponents;
    typedef ::CosTrading::SupportAttributes _VCHACK__CosTrading__SupportAttributes;
    typedef ::CosTrading::ImportAttributes _VCHACK__CosTrading__ImportAttributes;
    typedef ::CosTrading::LinkAttributes _VCHACK__CosTrading__LinkAttributes;
    virtual ~Admin();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Admin_ptr _ptr_type;
    typedef Admin_var _var_type;
    #endif

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

    static Admin_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    typedef SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> OctetSeq;
    #ifdef _WINDOWS
    static OctetSeq _dummy_OctetSeq;
    #endif
    typedef TSeqVar<SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> > OctetSeq_var;
    typedef TSeqOut<SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> > OctetSeq_out;

    static CORBA::TypeCodeConst _tc_OctetSeq;

    virtual OctetSeq* request_id_stem() = 0;

    virtual CORBA::ULong set_def_search_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_max_search_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_def_match_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_max_match_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_def_return_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_max_return_card( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_max_list( CORBA::ULong value ) = 0;
    virtual CORBA::Boolean set_supports_modifiable_properties( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean set_supports_dynamic_properties( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean set_supports_proxy_offers( CORBA::Boolean value ) = 0;
    virtual CORBA::ULong set_def_hop_count( CORBA::ULong value ) = 0;
    virtual CORBA::ULong set_max_hop_count( CORBA::ULong value ) = 0;
    virtual FollowOption set_def_follow_policy( FollowOption policy ) = 0;
    virtual FollowOption set_max_follow_policy( FollowOption policy ) = 0;
    virtual FollowOption set_max_link_follow_policy( FollowOption policy ) = 0;
    virtual TypeRepository_ptr set_type_repos( CORBA::Object_ptr repository ) = 0;
    virtual OctetSeq* set_request_id_stem( const OctetSeq& stem ) = 0;
    virtual void list_offers( CORBA::ULong how_many, OfferIdSeq_out ids, OfferIdIterator_out id_itr ) = 0;
    virtual void list_proxies( CORBA::ULong how_many, OfferIdSeq_out ids, OfferIdIterator_out id_itr ) = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Admin;

// Stub for interface Admin
class Admin_stub:
  virtual public Admin,
  virtual public ::CosTrading::TraderComponents_stub,
  virtual public ::CosTrading::SupportAttributes_stub,
  virtual public ::CosTrading::ImportAttributes_stub,
  virtual public ::CosTrading::LinkAttributes_stub
{
  public:
    virtual ~Admin_stub();
    OctetSeq* request_id_stem();

    CORBA::ULong set_def_search_card( CORBA::ULong value );
    CORBA::ULong set_max_search_card( CORBA::ULong value );
    CORBA::ULong set_def_match_card( CORBA::ULong value );
    CORBA::ULong set_max_match_card( CORBA::ULong value );
    CORBA::ULong set_def_return_card( CORBA::ULong value );
    CORBA::ULong set_max_return_card( CORBA::ULong value );
    CORBA::ULong set_max_list( CORBA::ULong value );
    CORBA::Boolean set_supports_modifiable_properties( CORBA::Boolean value );
    CORBA::Boolean set_supports_dynamic_properties( CORBA::Boolean value );
    CORBA::Boolean set_supports_proxy_offers( CORBA::Boolean value );
    CORBA::ULong set_def_hop_count( CORBA::ULong value );
    CORBA::ULong set_max_hop_count( CORBA::ULong value );
    FollowOption set_def_follow_policy( FollowOption policy );
    FollowOption set_max_follow_policy( FollowOption policy );
    FollowOption set_max_link_follow_policy( FollowOption policy );
    TypeRepository_ptr set_type_repos( CORBA::Object_ptr repository );
    OctetSeq* set_request_id_stem( const OctetSeq& stem );
    void list_offers( CORBA::ULong how_many, OfferIdSeq_out ids, OfferIdIterator_out id_itr );
    void list_proxies( CORBA::ULong how_many, OfferIdSeq_out ids, OfferIdIterator_out id_itr );

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

class Admin_skel :
  virtual public StaticMethodDispatcher,
  virtual public Admin
{
  public:
    Admin_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~Admin_skel();
    Admin_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    Admin_ptr _this();

};

struct UnknownMaxLeft : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  UnknownMaxLeft();
  ~UnknownMaxLeft();
  UnknownMaxLeft( const UnknownMaxLeft& s );
  UnknownMaxLeft& operator=( const UnknownMaxLeft& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  UnknownMaxLeft *operator->() { return this; }
  UnknownMaxLeft& operator*() { return *this; }
  operator UnknownMaxLeft*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static UnknownMaxLeft *_downcast( CORBA::Exception *ex );
  static const UnknownMaxLeft *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef UnknownMaxLeft UnknownMaxLeft_catch;
#else
typedef ExceptVar<UnknownMaxLeft> UnknownMaxLeft_var;
typedef TVarOut<UnknownMaxLeft> UnknownMaxLeft_out;
typedef UnknownMaxLeft_var UnknownMaxLeft_catch;
#endif // HAVE_STD_EH

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_UnknownMaxLeft;


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

class OfferIterator : 
  virtual public CORBA::Object
{
  public:
    virtual ~OfferIterator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OfferIterator_ptr _ptr_type;
    typedef OfferIterator_var _var_type;
    #endif

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

    static OfferIterator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong max_left() = 0;
    virtual CORBA::Boolean next_n( CORBA::ULong n, OfferSeq_out offers ) = 0;
    virtual void destroy() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_OfferIterator;

// Stub for interface OfferIterator
class OfferIterator_stub:
  virtual public OfferIterator
{
  public:
    virtual ~OfferIterator_stub();
    CORBA::ULong max_left();
    CORBA::Boolean next_n( CORBA::ULong n, OfferSeq_out offers );
    void destroy();

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

class OfferIterator_skel :
  virtual public StaticMethodDispatcher,
  virtual public OfferIterator
{
  public:
    OfferIterator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~OfferIterator_skel();
    OfferIterator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    OfferIterator_ptr _this();

};


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

class OfferIdIterator : 
  virtual public CORBA::Object
{
  public:
    virtual ~OfferIdIterator();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef OfferIdIterator_ptr _ptr_type;
    typedef OfferIdIterator_var _var_type;
    #endif

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

    static OfferIdIterator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong max_left() = 0;
    virtual CORBA::Boolean next_n( CORBA::ULong n, OfferIdSeq_out ids ) = 0;
    virtual void destroy() = 0;

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

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_OfferIdIterator;

// Stub for interface OfferIdIterator
class OfferIdIterator_stub:
  virtual public OfferIdIterator
{
  public:
    virtual ~OfferIdIterator_stub();
    CORBA::ULong max_left();
    CORBA::Boolean next_n( CORBA::ULong n, OfferIdSeq_out ids );
    void destroy();

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

class OfferIdIterator_skel :
  virtual public StaticMethodDispatcher,
  virtual public OfferIdIterator
{
  public:
    OfferIdIterator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~OfferIdIterator_skel();
    OfferIdIterator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment &_env );
    OfferIdIterator_ptr _this();

};

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

  CORBA::Object_var reference;
  PropertySeq properties;
};

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_Offer;

typedef StringSequenceTmpl<CORBA::String_var> StringList;
#ifdef _WINDOWS
static StringList _dummy_StringList;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > StringList_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > StringList_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_StringList;

typedef SequenceTmpl<CORBA::Long,MICO_TID_DEF> LongList;
#ifdef _WINDOWS
static LongList _dummy_LongList;
#endif
typedef TSeqVar<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > LongList_var;
typedef TSeqOut<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > LongList_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_LongList;

typedef SequenceTmpl<CORBA::Float,MICO_TID_DEF> FloatList;
#ifdef _WINDOWS
static FloatList _dummy_FloatList;
#endif
typedef TSeqVar<SequenceTmpl<CORBA::Float,MICO_TID_DEF> > FloatList_var;
typedef TSeqOut<SequenceTmpl<CORBA::Float,MICO_TID_DEF> > FloatList_out;

MICO_EXPORT_TYPEVAR_DECL CORBA::TypeCodeConst _tc_FloatList;

}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_TraderComponents;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_SupportAttributes;

void operator<<=( CORBA::Any &a, const ::CosTrading::FollowOption &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::FollowOption &e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_FollowOption;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_ImportAttributes;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Policy;

void operator<<=( CORBA::Any &a, const ::CosTrading::IllegalServiceType &e );
void operator<<=( CORBA::Any &a, ::CosTrading::IllegalServiceType *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::IllegalServiceType &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::IllegalServiceType *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_IllegalServiceType;

void operator<<=( CORBA::Any &a, const ::CosTrading::UnknownServiceType &e );
void operator<<=( CORBA::Any &a, ::CosTrading::UnknownServiceType *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::UnknownServiceType &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::UnknownServiceType *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_UnknownServiceType;

void operator<<=( CORBA::Any &a, const ::CosTrading::IllegalConstraint &e );
void operator<<=( CORBA::Any &a, ::CosTrading::IllegalConstraint *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::IllegalConstraint &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::IllegalConstraint *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_IllegalConstraint;

void operator<<=( CORBA::Any &a, const ::CosTrading::IllegalPropertyName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::IllegalPropertyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::IllegalPropertyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::IllegalPropertyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_IllegalPropertyName;

void operator<<=( CORBA::Any &a, const ::CosTrading::DuplicatePropertyName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::DuplicatePropertyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::DuplicatePropertyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::DuplicatePropertyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_DuplicatePropertyName;

void operator<<=( CORBA::Any &a, const ::CosTrading::DuplicatePolicyName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::DuplicatePolicyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::DuplicatePolicyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::DuplicatePolicyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_DuplicatePolicyName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Lookup::HowManyProps &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Lookup::HowManyProps &e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_HowManyProps;

void operator<<=( CORBA::Any &_a, const ::CosTrading::Lookup::SpecifiedProps &_u );
void operator<<=( CORBA::Any &_a, ::CosTrading::Lookup::SpecifiedProps *_u );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CosTrading::Lookup::SpecifiedProps &_u );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CosTrading::Lookup::SpecifiedProps *&_u );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_SpecifiedProps;

void operator<<=( CORBA::Any &a, const ::CosTrading::Lookup::IllegalPreference &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Lookup::IllegalPreference *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Lookup::IllegalPreference &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Lookup::IllegalPreference *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_IllegalPreference;

void operator<<=( CORBA::Any &a, const ::CosTrading::Lookup::IllegalPolicyName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Lookup::IllegalPolicyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Lookup::IllegalPolicyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Lookup::IllegalPolicyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_IllegalPolicyName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Lookup::PolicyTypeMismatch &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Lookup::PolicyTypeMismatch *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Lookup::PolicyTypeMismatch &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Lookup::PolicyTypeMismatch *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_PolicyTypeMismatch;

void operator<<=( CORBA::Any &a, const ::CosTrading::Lookup::InvalidPolicyValue &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Lookup::InvalidPolicyValue *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Lookup::InvalidPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Lookup::InvalidPolicyValue *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup_InvalidPolicyValue;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Lookup;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Property;

void operator<<=( CORBA::Any &a, const ::CosTrading::PropertyTypeMismatch &e );
void operator<<=( CORBA::Any &a, ::CosTrading::PropertyTypeMismatch *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::PropertyTypeMismatch &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::PropertyTypeMismatch *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_PropertyTypeMismatch;

void operator<<=( CORBA::Any &a, const ::CosTrading::ReadonlyDynamicProperty &e );
void operator<<=( CORBA::Any &a, ::CosTrading::ReadonlyDynamicProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::ReadonlyDynamicProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::ReadonlyDynamicProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_ReadonlyDynamicProperty;

void operator<<=( CORBA::Any &a, const ::CosTrading::MissingMandatoryProperty &e );
void operator<<=( CORBA::Any &a, ::CosTrading::MissingMandatoryProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::MissingMandatoryProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::MissingMandatoryProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_MissingMandatoryProperty;

void operator<<=( CORBA::Any &a, const ::CosTrading::IllegalOfferId &e );
void operator<<=( CORBA::Any &a, ::CosTrading::IllegalOfferId *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::IllegalOfferId &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::IllegalOfferId *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_IllegalOfferId;

void operator<<=( CORBA::Any &a, const ::CosTrading::UnknownOfferId &e );
void operator<<=( CORBA::Any &a, ::CosTrading::UnknownOfferId *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::UnknownOfferId &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::UnknownOfferId *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_UnknownOfferId;

void operator<<=( CORBA::Any &a, const ::CosTrading::NotImplemented &e );
void operator<<=( CORBA::Any &a, ::CosTrading::NotImplemented *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::NotImplemented &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::NotImplemented *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_NotImplemented;

void operator<<=( CORBA::Any &_a, const ::CosTrading::Register::OfferInfo &_s );
void operator<<=( CORBA::Any &_a, ::CosTrading::Register::OfferInfo *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CosTrading::Register::OfferInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CosTrading::Register::OfferInfo *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_OfferInfo;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::InvalidObjectRef &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::InvalidObjectRef *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::InvalidObjectRef &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::InvalidObjectRef *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_InvalidObjectRef;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::UnknownPropertyName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::UnknownPropertyName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::UnknownPropertyName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::UnknownPropertyName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_UnknownPropertyName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::InterfaceTypeMismatch &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::InterfaceTypeMismatch *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::InterfaceTypeMismatch &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::InterfaceTypeMismatch *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_InterfaceTypeMismatch;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::ProxyOfferId &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::ProxyOfferId *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::ProxyOfferId &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::ProxyOfferId *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_ProxyOfferId;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::MandatoryProperty &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::MandatoryProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::MandatoryProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::MandatoryProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_MandatoryProperty;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::ReadonlyProperty &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::ReadonlyProperty *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::ReadonlyProperty &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::ReadonlyProperty *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_ReadonlyProperty;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::NoMatchingOffers &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::NoMatchingOffers *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::NoMatchingOffers &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::NoMatchingOffers *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_NoMatchingOffers;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::IllegalTraderName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::IllegalTraderName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::IllegalTraderName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::IllegalTraderName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_IllegalTraderName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::UnknownTraderName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::UnknownTraderName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::UnknownTraderName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::UnknownTraderName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_UnknownTraderName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Register::RegisterNotSupported &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Register::RegisterNotSupported *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Register::RegisterNotSupported &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Register::RegisterNotSupported *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register_RegisterNotSupported;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Register;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_LinkAttributes;

void operator<<=( CORBA::Any &a, const ::CosTrading::InvalidLookupRef &e );
void operator<<=( CORBA::Any &a, ::CosTrading::InvalidLookupRef *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::InvalidLookupRef &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::InvalidLookupRef *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_InvalidLookupRef;

void operator<<=( CORBA::Any &_a, const ::CosTrading::Link::LinkInfo &_s );
void operator<<=( CORBA::Any &_a, ::CosTrading::Link::LinkInfo *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CosTrading::Link::LinkInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CosTrading::Link::LinkInfo *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_LinkInfo;

void operator<<=( CORBA::Any &a, const ::CosTrading::Link::IllegalLinkName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Link::IllegalLinkName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Link::IllegalLinkName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Link::IllegalLinkName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_IllegalLinkName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Link::UnknownLinkName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Link::UnknownLinkName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Link::UnknownLinkName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Link::UnknownLinkName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_UnknownLinkName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Link::DuplicateLinkName &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Link::DuplicateLinkName *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Link::DuplicateLinkName &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Link::DuplicateLinkName *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_DuplicateLinkName;

void operator<<=( CORBA::Any &a, const ::CosTrading::Link::DefaultFollowTooPermissive &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Link::DefaultFollowTooPermissive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Link::DefaultFollowTooPermissive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Link::DefaultFollowTooPermissive *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_DefaultFollowTooPermissive;

void operator<<=( CORBA::Any &a, const ::CosTrading::Link::LimitingFollowTooPermissive &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Link::LimitingFollowTooPermissive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Link::LimitingFollowTooPermissive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Link::LimitingFollowTooPermissive *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link_LimitingFollowTooPermissive;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Link;

void operator<<=( CORBA::Any &_a, const ::CosTrading::Proxy::ProxyInfo &_s );
void operator<<=( CORBA::Any &_a, ::CosTrading::Proxy::ProxyInfo *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CosTrading::Proxy::ProxyInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CosTrading::Proxy::ProxyInfo *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Proxy_ProxyInfo;

void operator<<=( CORBA::Any &a, const ::CosTrading::Proxy::IllegalRecipe &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Proxy::IllegalRecipe *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Proxy::IllegalRecipe &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Proxy::IllegalRecipe *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Proxy_IllegalRecipe;

void operator<<=( CORBA::Any &a, const ::CosTrading::Proxy::NotProxyOfferId &e );
void operator<<=( CORBA::Any &a, ::CosTrading::Proxy::NotProxyOfferId *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::Proxy::NotProxyOfferId &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::Proxy::NotProxyOfferId *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Proxy_NotProxyOfferId;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Proxy;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Admin;

void operator<<=( CORBA::Any &a, const ::CosTrading::UnknownMaxLeft &e );
void operator<<=( CORBA::Any &a, ::CosTrading::UnknownMaxLeft *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CosTrading::UnknownMaxLeft &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CosTrading::UnknownMaxLeft *&e );

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_UnknownMaxLeft;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_OfferIterator;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_OfferIdIterator;

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

extern CORBA::StaticTypeInfo *_marshaller_CosTrading_Offer;

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

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

extern CORBA::StaticTypeInfo *_marshaller__seq_CosTrading_Policy;

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

extern CORBA::StaticTypeInfo *_marshaller__seq_CosTrading_Offer;

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

extern CORBA::StaticTypeInfo *_marshaller__seq_CosTrading_Property;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,MICO_TID_OCTET> *&_s );

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

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

#endif
