/**
 * This file was generated by the Objective Systems ASN1C Compiler
 * (http://www.obj-sys.com).  Version: 5.63.
 */
#ifndef PKIX1EXPLICIT88_H
#define PKIX1EXPLICIT88_H

#include <stdio.h>
#include <stdlib.h>
#include "asn1BerCppTypes.h"
#include "asn1XerCppTypes.h"
#include "rtTable.h"
#include "ASN1CXerOpenType.h"
#include "ASN1CSeqOfList.h"
#include "ASN1CBitStr.h"
#include "PKIX1Explicit88BaseTypes.h"
namespace asn1data {

/**************************************************************/
/*                                                            */
/*  ContentTypeIdentifier                                     */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_ContentTypeIdentifier;

class EXTERN ASN1C_ContentTypeIdentifier :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ContentTypeIdentifier& msgData;
public:
   ASN1C_ContentTypeIdentifier (ASN1T_ContentTypeIdentifier& data);
   ASN1C_ContentTypeIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_ContentTypeIdentifier& data);
   ASN1C_ContentTypeIdentifier (ASN1C_ContentTypeIdentifier& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ContentTypeIdentifier& getCopy (ASN1T_ContentTypeIdentifier* pDstData = 0);
   ASN1T_ContentTypeIdentifier* newCopy ();

   inline ASN1C_ContentTypeIdentifier& operator= (ASN1C_ContentTypeIdentifier& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_ContentTypeIdentifier (ASN1CTXT* pctxt,
   ASN1T_ContentTypeIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ContentTypeIdentifier (ASN1CTXT* pctxt,
   ASN1T_ContentTypeIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ContentTypeIdentifier
  (ASN1CTXT* pctxt, ASN1T_ContentTypeIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ContentTypeIdentifier (ASN1CTXT *pctxt, ASN1T_ContentTypeIdentifier* pSrcValue, ASN1T_ContentTypeIdentifier* pDstValue);

/**************************************************************/
/*                                                            */
/*  CaseIgnoreIA5StringSyntax                                 */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_CaseIgnoreIA5StringSyntax;

class EXTERN ASN1C_CaseIgnoreIA5StringSyntax :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CaseIgnoreIA5StringSyntax& msgData;
public:
   ASN1C_CaseIgnoreIA5StringSyntax (ASN1T_CaseIgnoreIA5StringSyntax& data);
   ASN1C_CaseIgnoreIA5StringSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_CaseIgnoreIA5StringSyntax& data);
   ASN1C_CaseIgnoreIA5StringSyntax (ASN1C_CaseIgnoreIA5StringSyntax& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CaseIgnoreIA5StringSyntax& getCopy (ASN1T_CaseIgnoreIA5StringSyntax* pDstData = 0);
   ASN1T_CaseIgnoreIA5StringSyntax* newCopy ();

   inline ASN1C_CaseIgnoreIA5StringSyntax& operator= (ASN1C_CaseIgnoreIA5StringSyntax& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CaseIgnoreIA5StringSyntax (ASN1CTXT* pctxt,
   ASN1T_CaseIgnoreIA5StringSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CaseIgnoreIA5StringSyntax (ASN1CTXT* pctxt,
   ASN1T_CaseIgnoreIA5StringSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CaseIgnoreIA5StringSyntax
  (ASN1CTXT* pctxt, ASN1T_CaseIgnoreIA5StringSyntax value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CaseIgnoreIA5StringSyntax (ASN1CTXT *pctxt, ASN1T_CaseIgnoreIA5StringSyntax* pSrcValue, ASN1T_CaseIgnoreIA5StringSyntax* pDstValue);

EXTERN void asn1Free_CaseIgnoreIA5StringSyntax (ASN1CTXT *pctxt, ASN1T_CaseIgnoreIA5StringSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  PHGString                                                 */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_PHGString;

class EXTERN ASN1C_PHGString :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PHGString& msgData;
public:
   ASN1C_PHGString (ASN1T_PHGString& data);
   ASN1C_PHGString (
      ASN1MessageBufferIF& msgBuf, ASN1T_PHGString& data);
   ASN1C_PHGString (ASN1C_PHGString& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PHGString& getCopy (ASN1T_PHGString* pDstData = 0);
   ASN1T_PHGString* newCopy ();

   inline ASN1C_PHGString& operator= (ASN1C_PHGString& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PHGString (ASN1CTXT* pctxt,
   ASN1T_PHGString *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PHGString (ASN1CTXT* pctxt,
   ASN1T_PHGString *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PHGString
  (ASN1CTXT* pctxt, ASN1T_PHGString value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PHGString (ASN1CTXT *pctxt, ASN1T_PHGString* pSrcValue, ASN1T_PHGString* pDstValue);

EXTERN void asn1Free_PHGString (ASN1CTXT *pctxt, ASN1T_PHGString* pvalue);

/**************************************************************/
/*                                                            */
/*  CaseIgnoreIA5StringSyntaxNonStrict                        */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_CaseIgnoreIA5StringSyntaxNonStrict;

class EXTERN ASN1C_CaseIgnoreIA5StringSyntaxNonStrict :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CaseIgnoreIA5StringSyntaxNonStrict& msgData;
public:
   ASN1C_CaseIgnoreIA5StringSyntaxNonStrict (ASN1T_CaseIgnoreIA5StringSyntaxNonStrict& data);
   ASN1C_CaseIgnoreIA5StringSyntaxNonStrict (
      ASN1MessageBufferIF& msgBuf, ASN1T_CaseIgnoreIA5StringSyntaxNonStrict& data);
   ASN1C_CaseIgnoreIA5StringSyntaxNonStrict (ASN1C_CaseIgnoreIA5StringSyntaxNonStrict& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CaseIgnoreIA5StringSyntaxNonStrict& getCopy (ASN1T_CaseIgnoreIA5StringSyntaxNonStrict* pDstData = 0);
   ASN1T_CaseIgnoreIA5StringSyntaxNonStrict* newCopy ();

   inline ASN1C_CaseIgnoreIA5StringSyntaxNonStrict& operator= (ASN1C_CaseIgnoreIA5StringSyntaxNonStrict& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CaseIgnoreIA5StringSyntaxNonStrict (ASN1CTXT* pctxt,
   ASN1T_CaseIgnoreIA5StringSyntaxNonStrict *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CaseIgnoreIA5StringSyntaxNonStrict (ASN1CTXT* pctxt,
   ASN1T_CaseIgnoreIA5StringSyntaxNonStrict *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CaseIgnoreIA5StringSyntaxNonStrict
  (ASN1CTXT* pctxt, ASN1T_CaseIgnoreIA5StringSyntaxNonStrict value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CaseIgnoreIA5StringSyntaxNonStrict (ASN1CTXT *pctxt, ASN1T_CaseIgnoreIA5StringSyntaxNonStrict* pSrcValue, ASN1T_CaseIgnoreIA5StringSyntaxNonStrict* pDstValue);

EXTERN void asn1Free_CaseIgnoreIA5StringSyntaxNonStrict (ASN1CTXT *pctxt, ASN1T_CaseIgnoreIA5StringSyntaxNonStrict* pvalue);

/**************************************************************/
/*                                                            */
/*  PHGStringNonStrict                                        */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_PHGStringNonStrict;

class EXTERN ASN1C_PHGStringNonStrict :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PHGStringNonStrict& msgData;
public:
   ASN1C_PHGStringNonStrict (ASN1T_PHGStringNonStrict& data);
   ASN1C_PHGStringNonStrict (
      ASN1MessageBufferIF& msgBuf, ASN1T_PHGStringNonStrict& data);
   ASN1C_PHGStringNonStrict (ASN1C_PHGStringNonStrict& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PHGStringNonStrict& getCopy (ASN1T_PHGStringNonStrict* pDstData = 0);
   ASN1T_PHGStringNonStrict* newCopy ();

   inline ASN1C_PHGStringNonStrict& operator= (ASN1C_PHGStringNonStrict& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PHGStringNonStrict (ASN1CTXT* pctxt,
   ASN1T_PHGStringNonStrict *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PHGStringNonStrict (ASN1CTXT* pctxt,
   ASN1T_PHGStringNonStrict *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PHGStringNonStrict
  (ASN1CTXT* pctxt, ASN1T_PHGStringNonStrict value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PHGStringNonStrict (ASN1CTXT *pctxt, ASN1T_PHGStringNonStrict* pSrcValue, ASN1T_PHGStringNonStrict* pDstValue);

EXTERN void asn1Free_PHGStringNonStrict (ASN1CTXT *pctxt, ASN1T_PHGStringNonStrict* pvalue);

/**************************************************************/
/*                                                            */
/*  EnrollmentCSPInfo                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_EnrollmentCSPInfo;

typedef struct EXTERN ASN1T_EnrollmentCSPInfo : public ASN1TPDU {
   ASN1INT provType;
   ASN1BMPString name;
   ASN1TDynBitStr signature;
   ASN1T_EnrollmentCSPInfo ();
   ASN1T_EnrollmentCSPInfo (ASN1C_EnrollmentCSPInfo& srcData);
   ~ASN1T_EnrollmentCSPInfo ();
} ASN1T_EnrollmentCSPInfo;

class EXTERN ASN1C_EnrollmentCSPInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EnrollmentCSPInfo& msgData;
   struct ElementID {
      enum {
         _unknown, provType, name, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_EnrollmentCSPInfo (ASN1T_EnrollmentCSPInfo& data);
   ASN1C_EnrollmentCSPInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_EnrollmentCSPInfo& data);
   ASN1C_EnrollmentCSPInfo (ASN1C_EnrollmentCSPInfo& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_EnrollmentCSPInfo& getCopy (ASN1T_EnrollmentCSPInfo* pDstData = 0);
   ASN1T_EnrollmentCSPInfo* newCopy ();

   inline ASN1C_EnrollmentCSPInfo& operator= (ASN1C_EnrollmentCSPInfo& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_EnrollmentCSPInfo (ASN1CTXT* pctxt,
   ASN1T_EnrollmentCSPInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EnrollmentCSPInfo (ASN1CTXT* pctxt,
   ASN1T_EnrollmentCSPInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EnrollmentCSPInfo
  (ASN1CTXT* pctxt, ASN1T_EnrollmentCSPInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EnrollmentCSPInfo (ASN1CTXT *pctxt, ASN1T_EnrollmentCSPInfo* pSrcValue, ASN1T_EnrollmentCSPInfo* pDstValue);

EXTERN void asn1Free_EnrollmentCSPInfo (ASN1CTXT *pctxt, ASN1T_EnrollmentCSPInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  _msOsVersion_Type                                         */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T__msOsVersion_Type;

class EXTERN ASN1C__msOsVersion_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__msOsVersion_Type& msgData;
public:
   ASN1C__msOsVersion_Type (ASN1T__msOsVersion_Type& data);
   ASN1C__msOsVersion_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__msOsVersion_Type& data);
   ASN1C__msOsVersion_Type (ASN1C__msOsVersion_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__msOsVersion_Type& getCopy (ASN1T__msOsVersion_Type* pDstData = 0);
   ASN1T__msOsVersion_Type* newCopy ();

   inline ASN1C__msOsVersion_Type& operator= (ASN1C__msOsVersion_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E__msOsVersion_Type (ASN1CTXT* pctxt,
   ASN1T__msOsVersion_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__msOsVersion_Type (ASN1CTXT* pctxt,
   ASN1T__msOsVersion_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__msOsVersion_Type
  (ASN1CTXT* pctxt, ASN1T__msOsVersion_Type value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__msOsVersion_Type (ASN1CTXT *pctxt, ASN1T__msOsVersion_Type* pSrcValue, ASN1T__msOsVersion_Type* pDstValue);

EXTERN void asn1Free__msOsVersion_Type (ASN1CTXT *pctxt, ASN1T__msOsVersion_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _name_Type                                                */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__name_Type_utf8String         1
#define T__name_Type_numericString      2
#define T__name_Type_printableString    3
#define T__name_Type_teletexString      4
#define T__name_Type_ia5String          5
#define T__name_Type_universalString    6
#define T__name_Type_bmpString          7

class EXTERN ASN1C__name_Type;

typedef struct EXTERN ASN1T__name_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__name_Type () {}
   ASN1T__name_Type (ASN1C__name_Type& srcData);
   ~ASN1T__name_Type ();
} ASN1T__name_Type;

class EXTERN ASN1C__name_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__name_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__name_Type (ASN1T__name_Type& data);
   ASN1C__name_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__name_Type& data);
   ASN1C__name_Type (ASN1C__name_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__name_Type& getCopy (ASN1T__name_Type* pDstData = 0);
   ASN1T__name_Type* newCopy ();

   inline ASN1C__name_Type& operator= (ASN1C__name_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__name_Type (ASN1CTXT* pctxt,
   ASN1T__name_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__name_Type (ASN1CTXT* pctxt,
   ASN1T__name_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__name_Type
  (ASN1CTXT* pctxt, ASN1T__name_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__name_Type (ASN1CTXT *pctxt, ASN1T__name_Type* pSrcValue, ASN1T__name_Type* pDstValue);

EXTERN void asn1Free__name_Type (ASN1CTXT *pctxt, ASN1T__name_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _commonName_Type                                          */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__commonName_Type_utf8String   1
#define T__commonName_Type_numericString 2
#define T__commonName_Type_printableString 3
#define T__commonName_Type_teletexString 4
#define T__commonName_Type_ia5String    5
#define T__commonName_Type_universalString 6
#define T__commonName_Type_bmpString    7

class EXTERN ASN1C__commonName_Type;

typedef struct EXTERN ASN1T__commonName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__commonName_Type () {}
   ASN1T__commonName_Type (ASN1C__commonName_Type& srcData);
   ~ASN1T__commonName_Type ();
} ASN1T__commonName_Type;

class EXTERN ASN1C__commonName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__commonName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__commonName_Type (ASN1T__commonName_Type& data);
   ASN1C__commonName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__commonName_Type& data);
   ASN1C__commonName_Type (ASN1C__commonName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__commonName_Type& getCopy (ASN1T__commonName_Type* pDstData = 0);
   ASN1T__commonName_Type* newCopy ();

   inline ASN1C__commonName_Type& operator= (ASN1C__commonName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__commonName_Type (ASN1CTXT* pctxt,
   ASN1T__commonName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__commonName_Type (ASN1CTXT* pctxt,
   ASN1T__commonName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__commonName_Type
  (ASN1CTXT* pctxt, ASN1T__commonName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__commonName_Type (ASN1CTXT *pctxt, ASN1T__commonName_Type* pSrcValue, ASN1T__commonName_Type* pDstValue);

EXTERN void asn1Free__commonName_Type (ASN1CTXT *pctxt, ASN1T__commonName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _surname_Type                                             */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__surname_Type_utf8String      1
#define T__surname_Type_numericString   2
#define T__surname_Type_printableString 3
#define T__surname_Type_teletexString   4
#define T__surname_Type_ia5String       5
#define T__surname_Type_universalString 6
#define T__surname_Type_bmpString       7

class EXTERN ASN1C__surname_Type;

typedef struct EXTERN ASN1T__surname_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__surname_Type () {}
   ASN1T__surname_Type (ASN1C__surname_Type& srcData);
   ~ASN1T__surname_Type ();
} ASN1T__surname_Type;

class EXTERN ASN1C__surname_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__surname_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__surname_Type (ASN1T__surname_Type& data);
   ASN1C__surname_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__surname_Type& data);
   ASN1C__surname_Type (ASN1C__surname_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__surname_Type& getCopy (ASN1T__surname_Type* pDstData = 0);
   ASN1T__surname_Type* newCopy ();

   inline ASN1C__surname_Type& operator= (ASN1C__surname_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__surname_Type (ASN1CTXT* pctxt,
   ASN1T__surname_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__surname_Type (ASN1CTXT* pctxt,
   ASN1T__surname_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__surname_Type
  (ASN1CTXT* pctxt, ASN1T__surname_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__surname_Type (ASN1CTXT *pctxt, ASN1T__surname_Type* pSrcValue, ASN1T__surname_Type* pDstValue);

EXTERN void asn1Free__surname_Type (ASN1CTXT *pctxt, ASN1T__surname_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _givenName_Type                                           */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__givenName_Type_utf8String    1
#define T__givenName_Type_numericString 2
#define T__givenName_Type_printableString 3
#define T__givenName_Type_teletexString 4
#define T__givenName_Type_ia5String     5
#define T__givenName_Type_universalString 6
#define T__givenName_Type_bmpString     7

class EXTERN ASN1C__givenName_Type;

typedef struct EXTERN ASN1T__givenName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__givenName_Type () {}
   ASN1T__givenName_Type (ASN1C__givenName_Type& srcData);
   ~ASN1T__givenName_Type ();
} ASN1T__givenName_Type;

class EXTERN ASN1C__givenName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__givenName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__givenName_Type (ASN1T__givenName_Type& data);
   ASN1C__givenName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__givenName_Type& data);
   ASN1C__givenName_Type (ASN1C__givenName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__givenName_Type& getCopy (ASN1T__givenName_Type* pDstData = 0);
   ASN1T__givenName_Type* newCopy ();

   inline ASN1C__givenName_Type& operator= (ASN1C__givenName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__givenName_Type (ASN1CTXT* pctxt,
   ASN1T__givenName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__givenName_Type (ASN1CTXT* pctxt,
   ASN1T__givenName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__givenName_Type
  (ASN1CTXT* pctxt, ASN1T__givenName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__givenName_Type (ASN1CTXT *pctxt, ASN1T__givenName_Type* pSrcValue, ASN1T__givenName_Type* pDstValue);

EXTERN void asn1Free__givenName_Type (ASN1CTXT *pctxt, ASN1T__givenName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _initials_Type                                            */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__initials_Type_utf8String     1
#define T__initials_Type_numericString  2
#define T__initials_Type_printableString 3
#define T__initials_Type_teletexString  4
#define T__initials_Type_ia5String      5
#define T__initials_Type_universalString 6
#define T__initials_Type_bmpString      7

class EXTERN ASN1C__initials_Type;

typedef struct EXTERN ASN1T__initials_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__initials_Type () {}
   ASN1T__initials_Type (ASN1C__initials_Type& srcData);
   ~ASN1T__initials_Type ();
} ASN1T__initials_Type;

class EXTERN ASN1C__initials_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__initials_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__initials_Type (ASN1T__initials_Type& data);
   ASN1C__initials_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__initials_Type& data);
   ASN1C__initials_Type (ASN1C__initials_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__initials_Type& getCopy (ASN1T__initials_Type* pDstData = 0);
   ASN1T__initials_Type* newCopy ();

   inline ASN1C__initials_Type& operator= (ASN1C__initials_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__initials_Type (ASN1CTXT* pctxt,
   ASN1T__initials_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__initials_Type (ASN1CTXT* pctxt,
   ASN1T__initials_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__initials_Type
  (ASN1CTXT* pctxt, ASN1T__initials_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__initials_Type (ASN1CTXT *pctxt, ASN1T__initials_Type* pSrcValue, ASN1T__initials_Type* pDstValue);

EXTERN void asn1Free__initials_Type (ASN1CTXT *pctxt, ASN1T__initials_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _generationQualifier_Type                                 */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__generationQualifier_Type_utf8String 1
#define T__generationQualifier_Type_numericString 2
#define T__generationQualifier_Type_printableString 3
#define T__generationQualifier_Type_teletexString 4
#define T__generationQualifier_Type_ia5String 5
#define T__generationQualifier_Type_universalString 6
#define T__generationQualifier_Type_bmpString 7

class EXTERN ASN1C__generationQualifier_Type;

typedef struct EXTERN ASN1T__generationQualifier_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__generationQualifier_Type () {}
   ASN1T__generationQualifier_Type (ASN1C__generationQualifier_Type& srcData);
   ~ASN1T__generationQualifier_Type ();
} ASN1T__generationQualifier_Type;

class EXTERN ASN1C__generationQualifier_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__generationQualifier_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__generationQualifier_Type (ASN1T__generationQualifier_Type& data);
   ASN1C__generationQualifier_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__generationQualifier_Type& data);
   ASN1C__generationQualifier_Type (ASN1C__generationQualifier_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__generationQualifier_Type& getCopy (ASN1T__generationQualifier_Type* pDstData = 0);
   ASN1T__generationQualifier_Type* newCopy ();

   inline ASN1C__generationQualifier_Type& operator= (ASN1C__generationQualifier_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__generationQualifier_Type (ASN1CTXT* pctxt,
   ASN1T__generationQualifier_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__generationQualifier_Type (ASN1CTXT* pctxt,
   ASN1T__generationQualifier_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__generationQualifier_Type
  (ASN1CTXT* pctxt, ASN1T__generationQualifier_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__generationQualifier_Type (ASN1CTXT *pctxt, ASN1T__generationQualifier_Type* pSrcValue, ASN1T__generationQualifier_Type* pDstValue);

EXTERN void asn1Free__generationQualifier_Type (ASN1CTXT *pctxt, ASN1T__generationQualifier_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _localityName_Type                                        */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__localityName_Type_utf8String 1
#define T__localityName_Type_numericString 2
#define T__localityName_Type_printableString 3
#define T__localityName_Type_teletexString 4
#define T__localityName_Type_ia5String  5
#define T__localityName_Type_universalString 6
#define T__localityName_Type_bmpString  7

class EXTERN ASN1C__localityName_Type;

typedef struct EXTERN ASN1T__localityName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__localityName_Type () {}
   ASN1T__localityName_Type (ASN1C__localityName_Type& srcData);
   ~ASN1T__localityName_Type ();
} ASN1T__localityName_Type;

class EXTERN ASN1C__localityName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__localityName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__localityName_Type (ASN1T__localityName_Type& data);
   ASN1C__localityName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__localityName_Type& data);
   ASN1C__localityName_Type (ASN1C__localityName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__localityName_Type& getCopy (ASN1T__localityName_Type* pDstData = 0);
   ASN1T__localityName_Type* newCopy ();

   inline ASN1C__localityName_Type& operator= (ASN1C__localityName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__localityName_Type (ASN1CTXT* pctxt,
   ASN1T__localityName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__localityName_Type (ASN1CTXT* pctxt,
   ASN1T__localityName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__localityName_Type
  (ASN1CTXT* pctxt, ASN1T__localityName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__localityName_Type (ASN1CTXT *pctxt, ASN1T__localityName_Type* pSrcValue, ASN1T__localityName_Type* pDstValue);

EXTERN void asn1Free__localityName_Type (ASN1CTXT *pctxt, ASN1T__localityName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _streetAddress_Type                                       */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__streetAddress_Type_utf8String 1
#define T__streetAddress_Type_numericString 2
#define T__streetAddress_Type_printableString 3
#define T__streetAddress_Type_teletexString 4
#define T__streetAddress_Type_ia5String 5
#define T__streetAddress_Type_universalString 6
#define T__streetAddress_Type_bmpString 7

class EXTERN ASN1C__streetAddress_Type;

typedef struct EXTERN ASN1T__streetAddress_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__streetAddress_Type () {}
   ASN1T__streetAddress_Type (ASN1C__streetAddress_Type& srcData);
   ~ASN1T__streetAddress_Type ();
} ASN1T__streetAddress_Type;

class EXTERN ASN1C__streetAddress_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__streetAddress_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__streetAddress_Type (ASN1T__streetAddress_Type& data);
   ASN1C__streetAddress_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__streetAddress_Type& data);
   ASN1C__streetAddress_Type (ASN1C__streetAddress_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__streetAddress_Type& getCopy (ASN1T__streetAddress_Type* pDstData = 0);
   ASN1T__streetAddress_Type* newCopy ();

   inline ASN1C__streetAddress_Type& operator= (ASN1C__streetAddress_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__streetAddress_Type (ASN1CTXT* pctxt,
   ASN1T__streetAddress_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__streetAddress_Type (ASN1CTXT* pctxt,
   ASN1T__streetAddress_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__streetAddress_Type
  (ASN1CTXT* pctxt, ASN1T__streetAddress_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__streetAddress_Type (ASN1CTXT *pctxt, ASN1T__streetAddress_Type* pSrcValue, ASN1T__streetAddress_Type* pDstValue);

EXTERN void asn1Free__streetAddress_Type (ASN1CTXT *pctxt, ASN1T__streetAddress_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _stateOrProvinceName_Type                                 */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__stateOrProvinceName_Type_utf8String 1
#define T__stateOrProvinceName_Type_numericString 2
#define T__stateOrProvinceName_Type_printableString 3
#define T__stateOrProvinceName_Type_teletexString 4
#define T__stateOrProvinceName_Type_ia5String 5
#define T__stateOrProvinceName_Type_universalString 6
#define T__stateOrProvinceName_Type_bmpString 7

class EXTERN ASN1C__stateOrProvinceName_Type;

typedef struct EXTERN ASN1T__stateOrProvinceName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__stateOrProvinceName_Type () {}
   ASN1T__stateOrProvinceName_Type (ASN1C__stateOrProvinceName_Type& srcData);
   ~ASN1T__stateOrProvinceName_Type ();
} ASN1T__stateOrProvinceName_Type;

class EXTERN ASN1C__stateOrProvinceName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__stateOrProvinceName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__stateOrProvinceName_Type (ASN1T__stateOrProvinceName_Type& data);
   ASN1C__stateOrProvinceName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__stateOrProvinceName_Type& data);
   ASN1C__stateOrProvinceName_Type (ASN1C__stateOrProvinceName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__stateOrProvinceName_Type& getCopy (ASN1T__stateOrProvinceName_Type* pDstData = 0);
   ASN1T__stateOrProvinceName_Type* newCopy ();

   inline ASN1C__stateOrProvinceName_Type& operator= (ASN1C__stateOrProvinceName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__stateOrProvinceName_Type (ASN1CTXT* pctxt,
   ASN1T__stateOrProvinceName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__stateOrProvinceName_Type (ASN1CTXT* pctxt,
   ASN1T__stateOrProvinceName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__stateOrProvinceName_Type
  (ASN1CTXT* pctxt, ASN1T__stateOrProvinceName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__stateOrProvinceName_Type (ASN1CTXT *pctxt, ASN1T__stateOrProvinceName_Type* pSrcValue, ASN1T__stateOrProvinceName_Type* pDstValue);

EXTERN void asn1Free__stateOrProvinceName_Type (ASN1CTXT *pctxt, ASN1T__stateOrProvinceName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _organizationName_Type                                    */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__organizationName_Type_utf8String 1
#define T__organizationName_Type_numericString 2
#define T__organizationName_Type_printableString 3
#define T__organizationName_Type_teletexString 4
#define T__organizationName_Type_ia5String 5
#define T__organizationName_Type_universalString 6
#define T__organizationName_Type_bmpString 7

class EXTERN ASN1C__organizationName_Type;

typedef struct EXTERN ASN1T__organizationName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__organizationName_Type () {}
   ASN1T__organizationName_Type (ASN1C__organizationName_Type& srcData);
   ~ASN1T__organizationName_Type ();
} ASN1T__organizationName_Type;

class EXTERN ASN1C__organizationName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__organizationName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__organizationName_Type (ASN1T__organizationName_Type& data);
   ASN1C__organizationName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__organizationName_Type& data);
   ASN1C__organizationName_Type (ASN1C__organizationName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__organizationName_Type& getCopy (ASN1T__organizationName_Type* pDstData = 0);
   ASN1T__organizationName_Type* newCopy ();

   inline ASN1C__organizationName_Type& operator= (ASN1C__organizationName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__organizationName_Type (ASN1CTXT* pctxt,
   ASN1T__organizationName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__organizationName_Type (ASN1CTXT* pctxt,
   ASN1T__organizationName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__organizationName_Type
  (ASN1CTXT* pctxt, ASN1T__organizationName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__organizationName_Type (ASN1CTXT *pctxt, ASN1T__organizationName_Type* pSrcValue, ASN1T__organizationName_Type* pDstValue);

EXTERN void asn1Free__organizationName_Type (ASN1CTXT *pctxt, ASN1T__organizationName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _organizationalUnitName_Type                              */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__organizationalUnitName_Type_utf8String 1
#define T__organizationalUnitName_Type_numericString 2
#define T__organizationalUnitName_Type_printableString 3
#define T__organizationalUnitName_Type_teletexString 4
#define T__organizationalUnitName_Type_ia5String 5
#define T__organizationalUnitName_Type_universalString 6
#define T__organizationalUnitName_Type_bmpString 7

class EXTERN ASN1C__organizationalUnitName_Type;

typedef struct EXTERN ASN1T__organizationalUnitName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__organizationalUnitName_Type () {}
   ASN1T__organizationalUnitName_Type (ASN1C__organizationalUnitName_Type& srcData);
   ~ASN1T__organizationalUnitName_Type ();
} ASN1T__organizationalUnitName_Type;

class EXTERN ASN1C__organizationalUnitName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__organizationalUnitName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__organizationalUnitName_Type (ASN1T__organizationalUnitName_Type& data);
   ASN1C__organizationalUnitName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__organizationalUnitName_Type& data);
   ASN1C__organizationalUnitName_Type (ASN1C__organizationalUnitName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__organizationalUnitName_Type& getCopy (ASN1T__organizationalUnitName_Type* pDstData = 0);
   ASN1T__organizationalUnitName_Type* newCopy ();

   inline ASN1C__organizationalUnitName_Type& operator= (ASN1C__organizationalUnitName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__organizationalUnitName_Type (ASN1CTXT* pctxt,
   ASN1T__organizationalUnitName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__organizationalUnitName_Type (ASN1CTXT* pctxt,
   ASN1T__organizationalUnitName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__organizationalUnitName_Type
  (ASN1CTXT* pctxt, ASN1T__organizationalUnitName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__organizationalUnitName_Type (ASN1CTXT *pctxt, ASN1T__organizationalUnitName_Type* pSrcValue, ASN1T__organizationalUnitName_Type* pDstValue);

EXTERN void asn1Free__organizationalUnitName_Type (ASN1CTXT *pctxt, ASN1T__organizationalUnitName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _title_Type                                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__title_Type_utf8String        1
#define T__title_Type_numericString     2
#define T__title_Type_printableString   3
#define T__title_Type_teletexString     4
#define T__title_Type_ia5String         5
#define T__title_Type_universalString   6
#define T__title_Type_bmpString         7

class EXTERN ASN1C__title_Type;

typedef struct EXTERN ASN1T__title_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__title_Type () {}
   ASN1T__title_Type (ASN1C__title_Type& srcData);
   ~ASN1T__title_Type ();
} ASN1T__title_Type;

class EXTERN ASN1C__title_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__title_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__title_Type (ASN1T__title_Type& data);
   ASN1C__title_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__title_Type& data);
   ASN1C__title_Type (ASN1C__title_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__title_Type& getCopy (ASN1T__title_Type* pDstData = 0);
   ASN1T__title_Type* newCopy ();

   inline ASN1C__title_Type& operator= (ASN1C__title_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__title_Type (ASN1CTXT* pctxt,
   ASN1T__title_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__title_Type (ASN1CTXT* pctxt,
   ASN1T__title_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__title_Type
  (ASN1CTXT* pctxt, ASN1T__title_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__title_Type (ASN1CTXT *pctxt, ASN1T__title_Type* pSrcValue, ASN1T__title_Type* pDstValue);

EXTERN void asn1Free__title_Type (ASN1CTXT *pctxt, ASN1T__title_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _x520Pseudonym_Type                                       */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__x520Pseudonym_Type_utf8String 1
#define T__x520Pseudonym_Type_numericString 2
#define T__x520Pseudonym_Type_printableString 3
#define T__x520Pseudonym_Type_teletexString 4
#define T__x520Pseudonym_Type_ia5String 5
#define T__x520Pseudonym_Type_universalString 6
#define T__x520Pseudonym_Type_bmpString 7

class EXTERN ASN1C__x520Pseudonym_Type;

typedef struct EXTERN ASN1T__x520Pseudonym_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__x520Pseudonym_Type () {}
   ASN1T__x520Pseudonym_Type (ASN1C__x520Pseudonym_Type& srcData);
   ~ASN1T__x520Pseudonym_Type ();
} ASN1T__x520Pseudonym_Type;

class EXTERN ASN1C__x520Pseudonym_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__x520Pseudonym_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__x520Pseudonym_Type (ASN1T__x520Pseudonym_Type& data);
   ASN1C__x520Pseudonym_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__x520Pseudonym_Type& data);
   ASN1C__x520Pseudonym_Type (ASN1C__x520Pseudonym_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__x520Pseudonym_Type& getCopy (ASN1T__x520Pseudonym_Type* pDstData = 0);
   ASN1T__x520Pseudonym_Type* newCopy ();

   inline ASN1C__x520Pseudonym_Type& operator= (ASN1C__x520Pseudonym_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__x520Pseudonym_Type (ASN1CTXT* pctxt,
   ASN1T__x520Pseudonym_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__x520Pseudonym_Type (ASN1CTXT* pctxt,
   ASN1T__x520Pseudonym_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__x520Pseudonym_Type
  (ASN1CTXT* pctxt, ASN1T__x520Pseudonym_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__x520Pseudonym_Type (ASN1CTXT *pctxt, ASN1T__x520Pseudonym_Type* pSrcValue, ASN1T__x520Pseudonym_Type* pDstValue);

EXTERN void asn1Free__x520Pseudonym_Type (ASN1CTXT *pctxt, ASN1T__x520Pseudonym_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _messageDigest_Type                                       */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__messageDigest_Type;

class EXTERN ASN1C__messageDigest_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__messageDigest_Type& msgData;
public:
   ASN1C__messageDigest_Type (ASN1T__messageDigest_Type& data);
   ASN1C__messageDigest_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__messageDigest_Type& data);
   ASN1C__messageDigest_Type (ASN1C__messageDigest_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__messageDigest_Type& getCopy (ASN1T__messageDigest_Type* pDstData = 0);
   ASN1T__messageDigest_Type* newCopy ();

   inline ASN1C__messageDigest_Type& operator= (ASN1C__messageDigest_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E__messageDigest_Type (ASN1CTXT* pctxt,
   ASN1T__messageDigest_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__messageDigest_Type (ASN1CTXT* pctxt,
   ASN1T__messageDigest_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__messageDigest_Type
  (ASN1CTXT* pctxt, ASN1T__messageDigest_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__messageDigest_Type (ASN1CTXT *pctxt, ASN1T__messageDigest_Type* pSrcValue, ASN1T__messageDigest_Type* pDstValue);

EXTERN void asn1Free__messageDigest_Type (ASN1CTXT *pctxt, ASN1T__messageDigest_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  Time                                                      */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_Time_utcTime                  1
#define T_Time_generalTime              2

class EXTERN ASN1C_Time;

typedef struct EXTERN ASN1T_Time : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTCTime utcTime;
      /* t = 2 */
      ASN1GeneralizedTime generalTime;
   } u;
   ASN1T_Time () {}
   ASN1T_Time (ASN1C_Time& srcData);
   ~ASN1T_Time ();
} ASN1T_Time;

class EXTERN ASN1C_Time :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Time& msgData;
   struct ElementID {
      enum {
         _unknown, utcTime, generalTime
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_Time (ASN1T_Time& data);
   ASN1C_Time (
      ASN1MessageBufferIF& msgBuf, ASN1T_Time& data);
   ASN1C_Time (ASN1C_Time& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Time& getCopy (ASN1T_Time* pDstData = 0);
   ASN1T_Time* newCopy ();

   inline ASN1C_Time& operator= (ASN1C_Time& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Time (ASN1CTXT* pctxt,
   ASN1T_Time *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Time (ASN1CTXT* pctxt,
   ASN1T_Time *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Time
  (ASN1CTXT* pctxt, ASN1T_Time* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Time (ASN1CTXT *pctxt, ASN1T_Time* pSrcValue, ASN1T_Time* pDstValue);

EXTERN void asn1Free_Time (ASN1CTXT *pctxt, ASN1T_Time* pvalue);

/**************************************************************/
/*                                                            */
/*  CertHash                                                  */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_CertHash;

class EXTERN ASN1C_CertHash :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertHash& msgData;
public:
   ASN1C_CertHash (ASN1T_CertHash& data);
   ASN1C_CertHash (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertHash& data);
   ASN1C_CertHash (ASN1C_CertHash& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CertHash& getCopy (ASN1T_CertHash* pDstData = 0);
   ASN1T_CertHash* newCopy ();

   inline ASN1C_CertHash& operator= (ASN1C_CertHash& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CertHash (ASN1CTXT* pctxt,
   ASN1T_CertHash *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertHash (ASN1CTXT* pctxt,
   ASN1T_CertHash *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertHash
  (ASN1CTXT* pctxt, ASN1T_CertHash* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertHash (ASN1CTXT *pctxt, ASN1T_CertHash* pSrcValue, ASN1T_CertHash* pDstValue);

EXTERN void asn1Free_CertHash (ASN1CTXT *pctxt, ASN1T_CertHash* pvalue);

/**************************************************************/
/*                                                            */
/*  CountryName                                               */
/*                                                            */
/**************************************************************/

#define TV_CountryName	(TM_APPL|TM_CONS|1)

/* Choice tag constants */

#define T_CountryName_x121_dcc_code     1
#define T_CountryName_iso_3166_alpha2_code 2

class EXTERN ASN1C_CountryName;

typedef struct EXTERN ASN1T_CountryName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1NumericString x121_dcc_code;
      /* t = 2 */
      ASN1PrintableString iso_3166_alpha2_code;
   } u;
   ASN1T_CountryName () {}
   ASN1T_CountryName (ASN1C_CountryName& srcData);
   ~ASN1T_CountryName ();
} ASN1T_CountryName;

class EXTERN ASN1C_CountryName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CountryName& msgData;
   struct ElementID {
      enum {
         _unknown, x121_dcc_code, iso_3166_alpha2_code
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_CountryName (ASN1T_CountryName& data);
   ASN1C_CountryName (
      ASN1MessageBufferIF& msgBuf, ASN1T_CountryName& data);
   ASN1C_CountryName (ASN1C_CountryName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CountryName& getCopy (ASN1T_CountryName* pDstData = 0);
   ASN1T_CountryName* newCopy ();

   inline ASN1C_CountryName& operator= (ASN1C_CountryName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_CountryName (ASN1CTXT* pctxt,
   ASN1T_CountryName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CountryName (ASN1CTXT* pctxt,
   ASN1T_CountryName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CountryName
  (ASN1CTXT* pctxt, ASN1T_CountryName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CountryName (ASN1CTXT *pctxt, ASN1T_CountryName* pSrcValue, ASN1T_CountryName* pDstValue);

EXTERN void asn1Free_CountryName (ASN1CTXT *pctxt, ASN1T_CountryName* pvalue);

/**************************************************************/
/*                                                            */
/*  AdministrationDomainName                                  */
/*                                                            */
/**************************************************************/

#define TV_AdministrationDomainName	(TM_APPL|TM_CONS|2)

/* Choice tag constants */

#define T_AdministrationDomainName_numeric 1
#define T_AdministrationDomainName_printable 2

class EXTERN ASN1C_AdministrationDomainName;

typedef struct EXTERN ASN1T_AdministrationDomainName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1NumericString numeric;
      /* t = 2 */
      ASN1PrintableString printable;
   } u;
   ASN1T_AdministrationDomainName () {}
   ASN1T_AdministrationDomainName (ASN1C_AdministrationDomainName& srcData);
   ~ASN1T_AdministrationDomainName ();
} ASN1T_AdministrationDomainName;

class EXTERN ASN1C_AdministrationDomainName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AdministrationDomainName& msgData;
   struct ElementID {
      enum {
         _unknown, numeric, printable
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_AdministrationDomainName (ASN1T_AdministrationDomainName& data);
   ASN1C_AdministrationDomainName (
      ASN1MessageBufferIF& msgBuf, ASN1T_AdministrationDomainName& data);
   ASN1C_AdministrationDomainName (ASN1C_AdministrationDomainName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_AdministrationDomainName& getCopy (ASN1T_AdministrationDomainName* pDstData = 0);
   ASN1T_AdministrationDomainName* newCopy ();

   inline ASN1C_AdministrationDomainName& operator= (ASN1C_AdministrationDomainName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_AdministrationDomainName (ASN1CTXT* pctxt,
   ASN1T_AdministrationDomainName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AdministrationDomainName (ASN1CTXT* pctxt,
   ASN1T_AdministrationDomainName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AdministrationDomainName
  (ASN1CTXT* pctxt, ASN1T_AdministrationDomainName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AdministrationDomainName (ASN1CTXT *pctxt, ASN1T_AdministrationDomainName* pSrcValue, ASN1T_AdministrationDomainName* pDstValue);

EXTERN void asn1Free_AdministrationDomainName (ASN1CTXT *pctxt, ASN1T_AdministrationDomainName* pvalue);

/**************************************************************/
/*                                                            */
/*  X121Address                                               */
/*                                                            */
/**************************************************************/

typedef ASN1NumericString ASN1T_X121Address;

class EXTERN ASN1C_X121Address :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_X121Address& msgData;
public:
   ASN1C_X121Address (ASN1T_X121Address& data);
   ASN1C_X121Address (
      ASN1MessageBufferIF& msgBuf, ASN1T_X121Address& data);
   ASN1C_X121Address (ASN1C_X121Address& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_X121Address& getCopy (ASN1T_X121Address* pDstData = 0);
   ASN1T_X121Address* newCopy ();

   inline ASN1C_X121Address& operator= (ASN1C_X121Address& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_X121Address (ASN1CTXT* pctxt,
   ASN1T_X121Address *pvalue, ASN1TagType tagging);

EXTERN int asn1D_X121Address (ASN1CTXT* pctxt,
   ASN1T_X121Address *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_X121Address
  (ASN1CTXT* pctxt, ASN1T_X121Address value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_X121Address (ASN1CTXT *pctxt, ASN1T_X121Address* pSrcValue, ASN1T_X121Address* pDstValue);

EXTERN void asn1Free_X121Address (ASN1CTXT *pctxt, ASN1T_X121Address* pvalue);

/**************************************************************/
/*                                                            */
/*  NetworkAddress                                            */
/*                                                            */
/**************************************************************/

typedef ASN1T_X121Address ASN1T_NetworkAddress;

class EXTERN ASN1C_NetworkAddress :
   public ASN1C_X121Address
{
protected:
public:
   ASN1C_NetworkAddress (ASN1T_NetworkAddress& data);
   ASN1C_NetworkAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_NetworkAddress& data);
   ASN1C_NetworkAddress (ASN1C_NetworkAddress& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_NetworkAddress& getCopy (ASN1T_NetworkAddress* pDstData = 0);
   ASN1T_NetworkAddress* newCopy ();

   inline ASN1C_NetworkAddress& operator= (ASN1C_NetworkAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_NetworkAddress (ASN1CTXT* pctxt,
   ASN1T_NetworkAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NetworkAddress (ASN1CTXT* pctxt,
   ASN1T_NetworkAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_NetworkAddress
  (ASN1CTXT* pctxt, ASN1T_NetworkAddress value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_NetworkAddress (ASN1CTXT *pctxt, ASN1T_NetworkAddress* pSrcValue, ASN1T_NetworkAddress* pDstValue);

EXTERN void asn1Free_NetworkAddress (ASN1CTXT *pctxt, ASN1T_NetworkAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  TerminalIdentifier                                        */
/*                                                            */
/**************************************************************/

typedef ASN1PrintableString ASN1T_TerminalIdentifier;

class EXTERN ASN1C_TerminalIdentifier :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TerminalIdentifier& msgData;
public:
   ASN1C_TerminalIdentifier (ASN1T_TerminalIdentifier& data);
   ASN1C_TerminalIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_TerminalIdentifier& data);
   ASN1C_TerminalIdentifier (ASN1C_TerminalIdentifier& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TerminalIdentifier& getCopy (ASN1T_TerminalIdentifier* pDstData = 0);
   ASN1T_TerminalIdentifier* newCopy ();

   inline ASN1C_TerminalIdentifier& operator= (ASN1C_TerminalIdentifier& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_TerminalIdentifier (ASN1CTXT* pctxt,
   ASN1T_TerminalIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TerminalIdentifier (ASN1CTXT* pctxt,
   ASN1T_TerminalIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TerminalIdentifier
  (ASN1CTXT* pctxt, ASN1T_TerminalIdentifier value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TerminalIdentifier (ASN1CTXT *pctxt, ASN1T_TerminalIdentifier* pSrcValue, ASN1T_TerminalIdentifier* pDstValue);

EXTERN void asn1Free_TerminalIdentifier (ASN1CTXT *pctxt, ASN1T_TerminalIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  PrivateDomainName                                         */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PrivateDomainName_numeric     1
#define T_PrivateDomainName_printable   2

class EXTERN ASN1C_PrivateDomainName;

typedef struct EXTERN ASN1T_PrivateDomainName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1NumericString numeric;
      /* t = 2 */
      ASN1PrintableString printable;
   } u;
   ASN1T_PrivateDomainName () {}
   ASN1T_PrivateDomainName (ASN1C_PrivateDomainName& srcData);
   ~ASN1T_PrivateDomainName ();
} ASN1T_PrivateDomainName;

class EXTERN ASN1C_PrivateDomainName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PrivateDomainName& msgData;
   struct ElementID {
      enum {
         _unknown, numeric, printable
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_PrivateDomainName (ASN1T_PrivateDomainName& data);
   ASN1C_PrivateDomainName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PrivateDomainName& data);
   ASN1C_PrivateDomainName (ASN1C_PrivateDomainName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PrivateDomainName& getCopy (ASN1T_PrivateDomainName* pDstData = 0);
   ASN1T_PrivateDomainName* newCopy ();

   inline ASN1C_PrivateDomainName& operator= (ASN1C_PrivateDomainName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PrivateDomainName (ASN1CTXT* pctxt,
   ASN1T_PrivateDomainName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PrivateDomainName (ASN1CTXT* pctxt,
   ASN1T_PrivateDomainName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PrivateDomainName
  (ASN1CTXT* pctxt, ASN1T_PrivateDomainName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PrivateDomainName (ASN1CTXT *pctxt, ASN1T_PrivateDomainName* pSrcValue, ASN1T_PrivateDomainName* pDstValue);

EXTERN void asn1Free_PrivateDomainName (ASN1CTXT *pctxt, ASN1T_PrivateDomainName* pvalue);

/**************************************************************/
/*                                                            */
/*  OrganizationName                                          */
/*                                                            */
/**************************************************************/

typedef ASN1PrintableString ASN1T_OrganizationName;

class EXTERN ASN1C_OrganizationName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OrganizationName& msgData;
public:
   ASN1C_OrganizationName (ASN1T_OrganizationName& data);
   ASN1C_OrganizationName (
      ASN1MessageBufferIF& msgBuf, ASN1T_OrganizationName& data);
   ASN1C_OrganizationName (ASN1C_OrganizationName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OrganizationName& getCopy (ASN1T_OrganizationName* pDstData = 0);
   ASN1T_OrganizationName* newCopy ();

   inline ASN1C_OrganizationName& operator= (ASN1C_OrganizationName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_OrganizationName (ASN1CTXT* pctxt,
   ASN1T_OrganizationName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OrganizationName (ASN1CTXT* pctxt,
   ASN1T_OrganizationName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OrganizationName
  (ASN1CTXT* pctxt, ASN1T_OrganizationName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OrganizationName (ASN1CTXT *pctxt, ASN1T_OrganizationName* pSrcValue, ASN1T_OrganizationName* pDstValue);

EXTERN void asn1Free_OrganizationName (ASN1CTXT *pctxt, ASN1T_OrganizationName* pvalue);

/**************************************************************/
/*                                                            */
/*  NumericUserIdentifier                                     */
/*                                                            */
/**************************************************************/

typedef ASN1NumericString ASN1T_NumericUserIdentifier;

class EXTERN ASN1C_NumericUserIdentifier :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_NumericUserIdentifier& msgData;
public:
   ASN1C_NumericUserIdentifier (ASN1T_NumericUserIdentifier& data);
   ASN1C_NumericUserIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_NumericUserIdentifier& data);
   ASN1C_NumericUserIdentifier (ASN1C_NumericUserIdentifier& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_NumericUserIdentifier& getCopy (ASN1T_NumericUserIdentifier* pDstData = 0);
   ASN1T_NumericUserIdentifier* newCopy ();

   inline ASN1C_NumericUserIdentifier& operator= (ASN1C_NumericUserIdentifier& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_NumericUserIdentifier (ASN1CTXT* pctxt,
   ASN1T_NumericUserIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NumericUserIdentifier (ASN1CTXT* pctxt,
   ASN1T_NumericUserIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_NumericUserIdentifier
  (ASN1CTXT* pctxt, ASN1T_NumericUserIdentifier value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_NumericUserIdentifier (ASN1CTXT *pctxt, ASN1T_NumericUserIdentifier* pSrcValue, ASN1T_NumericUserIdentifier* pDstValue);

EXTERN void asn1Free_NumericUserIdentifier (ASN1CTXT *pctxt, ASN1T_NumericUserIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  PersonalName                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PersonalName;

typedef struct EXTERN ASN1T_PersonalName : public ASN1TPDU {
   struct {
      unsigned given_namePresent : 1;
      unsigned initialsPresent : 1;
      unsigned generation_qualifierPresent : 1;
   } m;
   ASN1PrintableString surname;
   ASN1PrintableString given_name;
   ASN1PrintableString initials;
   ASN1PrintableString generation_qualifier;
   ASN1T_PersonalName ();
   ASN1T_PersonalName (ASN1C_PersonalName& srcData);
   ~ASN1T_PersonalName ();
} ASN1T_PersonalName;

class EXTERN ASN1C_PersonalName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PersonalName& msgData;
   struct ElementID {
      enum {
         _unknown, surname, given_name, initials, generation_qualifier
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PersonalName (ASN1T_PersonalName& data);
   ASN1C_PersonalName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PersonalName& data);
   ASN1C_PersonalName (ASN1C_PersonalName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PersonalName& getCopy (ASN1T_PersonalName* pDstData = 0);
   ASN1T_PersonalName* newCopy ();

   inline ASN1C_PersonalName& operator= (ASN1C_PersonalName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PersonalName (ASN1CTXT* pctxt,
   ASN1T_PersonalName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PersonalName (ASN1CTXT* pctxt,
   ASN1T_PersonalName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PersonalName
  (ASN1CTXT* pctxt, ASN1T_PersonalName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PersonalName (ASN1CTXT *pctxt, ASN1T_PersonalName* pSrcValue, ASN1T_PersonalName* pDstValue);

EXTERN void asn1Free_PersonalName (ASN1CTXT *pctxt, ASN1T_PersonalName* pvalue);

/**************************************************************/
/*                                                            */
/*  OrganizationalUnitName                                    */
/*                                                            */
/**************************************************************/

typedef ASN1PrintableString ASN1T_OrganizationalUnitName;

class EXTERN ASN1C_OrganizationalUnitName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OrganizationalUnitName& msgData;
public:
   ASN1C_OrganizationalUnitName (ASN1T_OrganizationalUnitName& data);
   ASN1C_OrganizationalUnitName (
      ASN1MessageBufferIF& msgBuf, ASN1T_OrganizationalUnitName& data);
   ASN1C_OrganizationalUnitName (ASN1C_OrganizationalUnitName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OrganizationalUnitName& getCopy (ASN1T_OrganizationalUnitName* pDstData = 0);
   ASN1T_OrganizationalUnitName* newCopy ();

   inline ASN1C_OrganizationalUnitName& operator= (ASN1C_OrganizationalUnitName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_OrganizationalUnitName (ASN1CTXT* pctxt,
   ASN1T_OrganizationalUnitName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OrganizationalUnitName (ASN1CTXT* pctxt,
   ASN1T_OrganizationalUnitName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OrganizationalUnitName
  (ASN1CTXT* pctxt, ASN1T_OrganizationalUnitName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OrganizationalUnitName (ASN1CTXT *pctxt, ASN1T_OrganizationalUnitName* pSrcValue, ASN1T_OrganizationalUnitName* pDstValue);

EXTERN void asn1Free_OrganizationalUnitName (ASN1CTXT *pctxt, ASN1T_OrganizationalUnitName* pvalue);

/**************************************************************/
/*                                                            */
/*  OrganizationalUnitNames                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OrganizationalUnitNames;

typedef struct EXTERN ASN1T_OrganizationalUnitNames : public ASN1TPDU {
   ASN1UINT n;
   ASN1T_OrganizationalUnitName elem[4];
   ASN1T_OrganizationalUnitNames () : n (0) {}
   ASN1T_OrganizationalUnitNames (ASN1C_OrganizationalUnitNames& srcData);
   ~ASN1T_OrganizationalUnitNames ();
} ASN1T_OrganizationalUnitNames;

class EXTERN ASN1C_OrganizationalUnitNames :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OrganizationalUnitNames& msgData;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_OrganizationalUnitNames (ASN1T_OrganizationalUnitNames& data);
   ASN1C_OrganizationalUnitNames (
      ASN1MessageBufferIF& msgBuf, ASN1T_OrganizationalUnitNames& data);
   ASN1C_OrganizationalUnitNames (ASN1C_OrganizationalUnitNames& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OrganizationalUnitNames& getCopy (ASN1T_OrganizationalUnitNames* pDstData = 0);
   ASN1T_OrganizationalUnitNames* newCopy ();

   ASN1C_OrganizationalUnitNames& operator= (ASN1C_OrganizationalUnitNames& srcData);

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_OrganizationalUnitNames (ASN1CTXT* pctxt,
   ASN1T_OrganizationalUnitNames *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OrganizationalUnitNames (ASN1CTXT* pctxt,
   ASN1T_OrganizationalUnitNames *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OrganizationalUnitNames
  (ASN1CTXT* pctxt, ASN1T_OrganizationalUnitNames* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OrganizationalUnitNames (ASN1CTXT *pctxt, ASN1T_OrganizationalUnitNames* pSrcValue, ASN1T_OrganizationalUnitNames* pDstValue);

EXTERN void asn1Free_OrganizationalUnitNames (ASN1CTXT *pctxt, ASN1T_OrganizationalUnitNames* pvalue);

/**************************************************************/
/*                                                            */
/*  BuiltInStandardAttributes                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_BuiltInStandardAttributes;

typedef struct EXTERN ASN1T_BuiltInStandardAttributes : public ASN1TPDU {
   struct {
      unsigned country_namePresent : 1;
      unsigned administration_domain_namePresent : 1;
      unsigned network_addressPresent : 1;
      unsigned terminal_identifierPresent : 1;
      unsigned private_domain_namePresent : 1;
      unsigned organization_namePresent : 1;
      unsigned numeric_user_identifierPresent : 1;
      unsigned personal_namePresent : 1;
      unsigned organizational_unit_namesPresent : 1;
   } m;
   ASN1T_CountryName country_name;
   ASN1T_AdministrationDomainName administration_domain_name;
   ASN1T_NetworkAddress network_address;
   ASN1T_TerminalIdentifier terminal_identifier;
   ASN1T_PrivateDomainName private_domain_name;
   ASN1T_OrganizationName organization_name;
   ASN1T_NumericUserIdentifier numeric_user_identifier;
   ASN1T_PersonalName personal_name;
   ASN1T_OrganizationalUnitNames organizational_unit_names;
   ASN1T_BuiltInStandardAttributes ();
   ASN1T_BuiltInStandardAttributes (ASN1C_BuiltInStandardAttributes& srcData);
   ~ASN1T_BuiltInStandardAttributes ();
} ASN1T_BuiltInStandardAttributes;

class EXTERN ASN1C_BuiltInStandardAttributes :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BuiltInStandardAttributes& msgData;
   struct ElementID {
      enum {
         _unknown, country_name, administration_domain_name, network_address,
         terminal_identifier, private_domain_name, organization_name,
         numeric_user_identifier, personal_name, organizational_unit_names
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CountryName* mpCountry_nameC;
   class ASN1C_AdministrationDomainName* mpAdministration_domain_nameC;
   class ASN1C_PrivateDomainName* mpPrivate_domain_nameC;
   class ASN1C_PersonalName* mpPersonal_nameC;
   class ASN1C_OrganizationalUnitNames* mpOrganizational_unit_namesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_BuiltInStandardAttributes (ASN1T_BuiltInStandardAttributes& data);
   ASN1C_BuiltInStandardAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_BuiltInStandardAttributes& data);
   ASN1C_BuiltInStandardAttributes (ASN1C_BuiltInStandardAttributes& original);

   ~ASN1C_BuiltInStandardAttributes();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_BuiltInStandardAttributes& getCopy (ASN1T_BuiltInStandardAttributes* pDstData = 0);
   ASN1T_BuiltInStandardAttributes* newCopy ();

   inline ASN1C_BuiltInStandardAttributes& operator= (ASN1C_BuiltInStandardAttributes& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_BuiltInStandardAttributes (ASN1CTXT* pctxt,
   ASN1T_BuiltInStandardAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BuiltInStandardAttributes (ASN1CTXT* pctxt,
   ASN1T_BuiltInStandardAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BuiltInStandardAttributes
  (ASN1CTXT* pctxt, ASN1T_BuiltInStandardAttributes* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BuiltInStandardAttributes (ASN1CTXT *pctxt, ASN1T_BuiltInStandardAttributes* pSrcValue, ASN1T_BuiltInStandardAttributes* pDstValue);

EXTERN void asn1Free_BuiltInStandardAttributes (ASN1CTXT *pctxt, ASN1T_BuiltInStandardAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  BuiltInDomainDefinedAttribute                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_BuiltInDomainDefinedAttribute;

typedef struct EXTERN ASN1T_BuiltInDomainDefinedAttribute : public ASN1TPDU {
   ASN1PrintableString type;
   ASN1PrintableString value;
   ASN1T_BuiltInDomainDefinedAttribute ();
   ASN1T_BuiltInDomainDefinedAttribute (ASN1C_BuiltInDomainDefinedAttribute& srcData);
   ~ASN1T_BuiltInDomainDefinedAttribute ();
} ASN1T_BuiltInDomainDefinedAttribute;

class EXTERN ASN1C_BuiltInDomainDefinedAttribute :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BuiltInDomainDefinedAttribute& msgData;
   struct ElementID {
      enum {
         _unknown, type, value
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_BuiltInDomainDefinedAttribute (ASN1T_BuiltInDomainDefinedAttribute& data);
   ASN1C_BuiltInDomainDefinedAttribute (
      ASN1MessageBufferIF& msgBuf, ASN1T_BuiltInDomainDefinedAttribute& data);
   ASN1C_BuiltInDomainDefinedAttribute (ASN1C_BuiltInDomainDefinedAttribute& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_BuiltInDomainDefinedAttribute& getCopy (ASN1T_BuiltInDomainDefinedAttribute* pDstData = 0);
   ASN1T_BuiltInDomainDefinedAttribute* newCopy ();

   inline ASN1C_BuiltInDomainDefinedAttribute& operator= (ASN1C_BuiltInDomainDefinedAttribute& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_BuiltInDomainDefinedAttribute (ASN1CTXT* pctxt,
   ASN1T_BuiltInDomainDefinedAttribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BuiltInDomainDefinedAttribute (ASN1CTXT* pctxt,
   ASN1T_BuiltInDomainDefinedAttribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BuiltInDomainDefinedAttribute
  (ASN1CTXT* pctxt, ASN1T_BuiltInDomainDefinedAttribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BuiltInDomainDefinedAttribute (ASN1CTXT *pctxt, ASN1T_BuiltInDomainDefinedAttribute* pSrcValue, ASN1T_BuiltInDomainDefinedAttribute* pDstValue);

EXTERN void asn1Free_BuiltInDomainDefinedAttribute (ASN1CTXT *pctxt, ASN1T_BuiltInDomainDefinedAttribute* pvalue);

/**************************************************************/
/*                                                            */
/*  BuiltInDomainDefinedAttributes                            */
/*                                                            */
/**************************************************************/

/* List of ASN1T_BuiltInDomainDefinedAttribute */
typedef struct EXTERN ASN1T_BuiltInDomainDefinedAttributes : public ASN1TPDUSeqOfList {
   ~ASN1T_BuiltInDomainDefinedAttributes();
} ASN1T_BuiltInDomainDefinedAttributes;

class EXTERN ASN1C_BuiltInDomainDefinedAttributes :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BuiltInDomainDefinedAttributes& msgData;
   ASN1T_BuiltInDomainDefinedAttribute *mpElement;
   class ASN1C_BuiltInDomainDefinedAttribute* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_BuiltInDomainDefinedAttributes (ASN1T_BuiltInDomainDefinedAttributes& data);
   ASN1C_BuiltInDomainDefinedAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_BuiltInDomainDefinedAttributes& data);
   ASN1C_BuiltInDomainDefinedAttributes (ASN1C_BuiltInDomainDefinedAttributes& original);

   ~ASN1C_BuiltInDomainDefinedAttributes();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_BuiltInDomainDefinedAttributes& getCopy (ASN1T_BuiltInDomainDefinedAttributes* pDstData = 0);
   ASN1T_BuiltInDomainDefinedAttributes* newCopy ();

   ASN1C_BuiltInDomainDefinedAttributes& operator= (ASN1C_BuiltInDomainDefinedAttributes& srcData);
   void Append (ASN1T_BuiltInDomainDefinedAttribute * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_BuiltInDomainDefinedAttributes (ASN1CTXT* pctxt,
   ASN1T_BuiltInDomainDefinedAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BuiltInDomainDefinedAttributes (ASN1CTXT* pctxt,
   ASN1T_BuiltInDomainDefinedAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BuiltInDomainDefinedAttributes
  (ASN1CTXT* pctxt, ASN1T_BuiltInDomainDefinedAttributes* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BuiltInDomainDefinedAttributes (ASN1CTXT *pctxt, ASN1T_BuiltInDomainDefinedAttributes* pSrcValue, ASN1T_BuiltInDomainDefinedAttributes* pDstValue);

EXTERN void asn1Free_BuiltInDomainDefinedAttributes (ASN1CTXT *pctxt, ASN1T_BuiltInDomainDefinedAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtensionAttribute                                        */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ExtensionAttribute;

typedef struct EXTERN ASN1T_ExtensionAttribute : public ASN1TPDU {
   ASN1USINT extension_attribute_type;
   ASN1TOpenType extension_attribute_value;
   ASN1T_ExtensionAttribute ();
   ASN1T_ExtensionAttribute (ASN1C_ExtensionAttribute& srcData);
   ~ASN1T_ExtensionAttribute ();
} ASN1T_ExtensionAttribute;

class EXTERN ASN1C_ExtensionAttribute :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ExtensionAttribute& msgData;
   struct ElementID {
      enum {
         _unknown, extension_attribute_type, extension_attribute_value
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1CXerOpenType* mpExtension_attribute_valueC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_ExtensionAttribute (ASN1T_ExtensionAttribute& data);
   ASN1C_ExtensionAttribute (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtensionAttribute& data);
   ASN1C_ExtensionAttribute (ASN1C_ExtensionAttribute& original);

   ~ASN1C_ExtensionAttribute();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtensionAttribute& getCopy (ASN1T_ExtensionAttribute* pDstData = 0);
   ASN1T_ExtensionAttribute* newCopy ();

   inline ASN1C_ExtensionAttribute& operator= (ASN1C_ExtensionAttribute& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ExtensionAttribute (ASN1CTXT* pctxt,
   ASN1T_ExtensionAttribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtensionAttribute (ASN1CTXT* pctxt,
   ASN1T_ExtensionAttribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtensionAttribute
  (ASN1CTXT* pctxt, ASN1T_ExtensionAttribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtensionAttribute (ASN1CTXT *pctxt, ASN1T_ExtensionAttribute* pSrcValue, ASN1T_ExtensionAttribute* pDstValue);

EXTERN void asn1Free_ExtensionAttribute (ASN1CTXT *pctxt, ASN1T_ExtensionAttribute* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtensionAttributes                                       */
/*                                                            */
/**************************************************************/

/* List of ASN1T_ExtensionAttribute */
typedef struct EXTERN ASN1T_ExtensionAttributes : public ASN1TPDUSeqOfList {
   ~ASN1T_ExtensionAttributes();
} ASN1T_ExtensionAttributes;

class EXTERN ASN1C_ExtensionAttributes :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ExtensionAttributes& msgData;
   ASN1T_ExtensionAttribute *mpElement;
   class ASN1C_ExtensionAttribute* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_ExtensionAttributes (ASN1T_ExtensionAttributes& data);
   ASN1C_ExtensionAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtensionAttributes& data);
   ASN1C_ExtensionAttributes (ASN1C_ExtensionAttributes& original);

   ~ASN1C_ExtensionAttributes();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtensionAttributes& getCopy (ASN1T_ExtensionAttributes* pDstData = 0);
   ASN1T_ExtensionAttributes* newCopy ();

   ASN1C_ExtensionAttributes& operator= (ASN1C_ExtensionAttributes& srcData);
   void Append (ASN1T_ExtensionAttribute * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ExtensionAttributes (ASN1CTXT* pctxt,
   ASN1T_ExtensionAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtensionAttributes (ASN1CTXT* pctxt,
   ASN1T_ExtensionAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtensionAttributes
  (ASN1CTXT* pctxt, ASN1T_ExtensionAttributes* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtensionAttributes (ASN1CTXT *pctxt, ASN1T_ExtensionAttributes* pSrcValue, ASN1T_ExtensionAttributes* pDstValue);

EXTERN void asn1Free_ExtensionAttributes (ASN1CTXT *pctxt, ASN1T_ExtensionAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  ORAddress                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ORAddress;

typedef struct EXTERN ASN1T_ORAddress : public ASN1TPDU {
   struct {
      unsigned built_in_domain_defined_attributesPresent : 1;
      unsigned extension_attributesPresent : 1;
   } m;
   ASN1T_BuiltInStandardAttributes built_in_standard_attributes;
   ASN1T_BuiltInDomainDefinedAttributes built_in_domain_defined_attributes;
   ASN1T_ExtensionAttributes extension_attributes;
   ASN1T_ORAddress ();
   ASN1T_ORAddress (ASN1C_ORAddress& srcData);
   ~ASN1T_ORAddress ();
} ASN1T_ORAddress;

class EXTERN ASN1C_ORAddress :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ORAddress& msgData;
   struct ElementID {
      enum {
         _unknown, built_in_standard_attributes,
         built_in_domain_defined_attributes, extension_attributes
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_BuiltInStandardAttributes* mpBuilt_in_standard_attributesC;
   class ASN1C_BuiltInDomainDefinedAttributes* mpBuilt_in_domain_defined_attributesC;
   class ASN1C_ExtensionAttributes* mpExtension_attributesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_ORAddress (ASN1T_ORAddress& data);
   ASN1C_ORAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_ORAddress& data);
   ASN1C_ORAddress (ASN1C_ORAddress& original);

   ~ASN1C_ORAddress();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ORAddress& getCopy (ASN1T_ORAddress* pDstData = 0);
   ASN1T_ORAddress* newCopy ();

   inline ASN1C_ORAddress& operator= (ASN1C_ORAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ORAddress (ASN1CTXT* pctxt,
   ASN1T_ORAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ORAddress (ASN1CTXT* pctxt,
   ASN1T_ORAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ORAddress
  (ASN1CTXT* pctxt, ASN1T_ORAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ORAddress (ASN1CTXT *pctxt, ASN1T_ORAddress* pSrcValue, ASN1T_ORAddress* pDstValue);

EXTERN void asn1Free_ORAddress (ASN1CTXT *pctxt, ASN1T_ORAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  Name                                                      */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_Name_rdnSequence              1

class EXTERN ASN1C_Name;

typedef struct EXTERN ASN1T_Name : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1TSeqOfList *rdnSequence;
   } u;
   ASN1T_Name () {}
   ASN1T_Name (ASN1C_Name& srcData);
   ~ASN1T_Name ();
} ASN1T_Name;

class EXTERN ASN1C_Name :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Name& msgData;
   struct ElementID {
      enum {
         _unknown, rdnSequence
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_RDNSequence* mpRdnSequenceC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_Name (ASN1T_Name& data);
   ASN1C_Name (
      ASN1MessageBufferIF& msgBuf, ASN1T_Name& data);
   ASN1C_Name (ASN1C_Name& original);

   ~ASN1C_Name();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Name& getCopy (ASN1T_Name* pDstData = 0);
   ASN1T_Name* newCopy ();

   inline ASN1C_Name& operator= (ASN1C_Name& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Name (ASN1CTXT* pctxt,
   ASN1T_Name *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Name (ASN1CTXT* pctxt,
   ASN1T_Name *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Name
  (ASN1CTXT* pctxt, ASN1T_Name* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Name (ASN1CTXT *pctxt, ASN1T_Name* pSrcValue, ASN1T_Name* pDstValue);

EXTERN void asn1Free_Name (ASN1CTXT *pctxt, ASN1T_Name* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateSerialNumber                                   */
/*                                                            */
/**************************************************************/

typedef ASN1ConstCharPtr ASN1T_CertificateSerialNumber;

class EXTERN ASN1C_CertificateSerialNumber :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificateSerialNumber& msgData;
public:
   ASN1C_CertificateSerialNumber (ASN1T_CertificateSerialNumber& data);
   ASN1C_CertificateSerialNumber (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateSerialNumber& data);
   ASN1C_CertificateSerialNumber (ASN1C_CertificateSerialNumber& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CertificateSerialNumber& getCopy (ASN1T_CertificateSerialNumber* pDstData = 0);
   ASN1T_CertificateSerialNumber* newCopy ();

   inline ASN1C_CertificateSerialNumber& operator= (ASN1C_CertificateSerialNumber& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CertificateSerialNumber (ASN1CTXT* pctxt,
   ASN1T_CertificateSerialNumber *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateSerialNumber (ASN1CTXT* pctxt,
   ASN1T_CertificateSerialNumber *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateSerialNumber
  (ASN1CTXT* pctxt, ASN1T_CertificateSerialNumber value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateSerialNumber (ASN1CTXT *pctxt, ASN1T_CertificateSerialNumber* pSrcValue, ASN1T_CertificateSerialNumber* pDstValue);

/**************************************************************/
/*                                                            */
/*  UniqueIdentifier                                          */
/*                                                            */
/**************************************************************/

typedef ASN1TDynBitStr ASN1T_UniqueIdentifier;

class EXTERN ASN1C_UniqueIdentifier :
   public ASN1CBitStr, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_UniqueIdentifier& msgData;
public:
   ASN1C_UniqueIdentifier (ASN1T_UniqueIdentifier& data);
   ASN1C_UniqueIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_UniqueIdentifier& data);
   ASN1C_UniqueIdentifier (ASN1C_UniqueIdentifier& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_UniqueIdentifier& getCopy (ASN1T_UniqueIdentifier* pDstData = 0);
   ASN1T_UniqueIdentifier* newCopy ();

   ASN1C_UniqueIdentifier& operator= (ASN1C_UniqueIdentifier& srcData);
} ;

EXTERN int asn1E_UniqueIdentifier (ASN1CTXT* pctxt,
   ASN1T_UniqueIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_UniqueIdentifier (ASN1CTXT* pctxt,
   ASN1T_UniqueIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_UniqueIdentifier
  (ASN1CTXT* pctxt, ASN1T_UniqueIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_UniqueIdentifier (ASN1CTXT *pctxt, ASN1T_UniqueIdentifier* pSrcValue, ASN1T_UniqueIdentifier* pDstValue);

EXTERN void asn1Free_UniqueIdentifier (ASN1CTXT *pctxt, ASN1T_UniqueIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  IssuerSerial                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_IssuerSerial;

typedef struct EXTERN ASN1T_IssuerSerial : public ASN1TPDU {
   struct {
      unsigned issuerUIDPresent : 1;
   } m;
   ASN1TSeqOfList issuer;
   ASN1T_CertificateSerialNumber serialNumber;
   ASN1T_UniqueIdentifier issuerUID;
   ASN1T_IssuerSerial ();
   ASN1T_IssuerSerial (ASN1C_IssuerSerial& srcData);
   ~ASN1T_IssuerSerial ();
} ASN1T_IssuerSerial;

class EXTERN ASN1C_IssuerSerial :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_IssuerSerial& msgData;
   struct ElementID {
      enum {
         _unknown, issuer, serialNumber, issuerUID
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralNames* mpIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_IssuerSerial (ASN1T_IssuerSerial& data);
   ASN1C_IssuerSerial (
      ASN1MessageBufferIF& msgBuf, ASN1T_IssuerSerial& data);
   ASN1C_IssuerSerial (ASN1C_IssuerSerial& original);

   ~ASN1C_IssuerSerial();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_IssuerSerial& getCopy (ASN1T_IssuerSerial* pDstData = 0);
   ASN1T_IssuerSerial* newCopy ();

   inline ASN1C_IssuerSerial& operator= (ASN1C_IssuerSerial& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_IssuerSerial (ASN1CTXT* pctxt,
   ASN1T_IssuerSerial *pvalue, ASN1TagType tagging);

EXTERN int asn1D_IssuerSerial (ASN1CTXT* pctxt,
   ASN1T_IssuerSerial *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_IssuerSerial
  (ASN1CTXT* pctxt, ASN1T_IssuerSerial* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_IssuerSerial (ASN1CTXT *pctxt, ASN1T_IssuerSerial* pSrcValue, ASN1T_IssuerSerial* pDstValue);

EXTERN void asn1Free_IssuerSerial (ASN1CTXT *pctxt, ASN1T_IssuerSerial* pvalue);

/**************************************************************/
/*                                                            */
/*  ESSCertID                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ESSCertID;

typedef struct EXTERN ASN1T_ESSCertID : public ASN1TPDU {
   struct {
      unsigned issuerSerialPresent : 1;
   } m;
   ASN1T_CertHash certHash;
   ASN1T_IssuerSerial issuerSerial;
   ASN1T_ESSCertID ();
   ASN1T_ESSCertID (ASN1C_ESSCertID& srcData);
   ~ASN1T_ESSCertID ();
} ASN1T_ESSCertID;

class EXTERN ASN1C_ESSCertID :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ESSCertID& msgData;
   struct ElementID {
      enum {
         _unknown, certHash, issuerSerial
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_IssuerSerial* mpIssuerSerialC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_ESSCertID (ASN1T_ESSCertID& data);
   ASN1C_ESSCertID (
      ASN1MessageBufferIF& msgBuf, ASN1T_ESSCertID& data);
   ASN1C_ESSCertID (ASN1C_ESSCertID& original);

   ~ASN1C_ESSCertID();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ESSCertID& getCopy (ASN1T_ESSCertID* pDstData = 0);
   ASN1T_ESSCertID* newCopy ();

   inline ASN1C_ESSCertID& operator= (ASN1C_ESSCertID& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ESSCertID (ASN1CTXT* pctxt,
   ASN1T_ESSCertID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESSCertID (ASN1CTXT* pctxt,
   ASN1T_ESSCertID *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ESSCertID
  (ASN1CTXT* pctxt, ASN1T_ESSCertID* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ESSCertID (ASN1CTXT *pctxt, ASN1T_ESSCertID* pSrcValue, ASN1T_ESSCertID* pDstValue);

EXTERN void asn1Free_ESSCertID (ASN1CTXT *pctxt, ASN1T_ESSCertID* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfESSCertID                                           */
/*                                                            */
/**************************************************************/

/* List of ASN1T_ESSCertID */
typedef struct EXTERN ASN1T__SeqOfESSCertID : public ASN1TPDUSeqOfList {
   ~ASN1T__SeqOfESSCertID();
} ASN1T__SeqOfESSCertID;

class EXTERN ASN1C__SeqOfESSCertID :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SeqOfESSCertID& msgData;
   ASN1T_ESSCertID *mpElement;
   class ASN1C_ESSCertID* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SeqOfESSCertID (ASN1T__SeqOfESSCertID& data);
   ASN1C__SeqOfESSCertID (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfESSCertID& data);
   ASN1C__SeqOfESSCertID (ASN1C__SeqOfESSCertID& original);

   ~ASN1C__SeqOfESSCertID();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SeqOfESSCertID& getCopy (ASN1T__SeqOfESSCertID* pDstData = 0);
   ASN1T__SeqOfESSCertID* newCopy ();

   ASN1C__SeqOfESSCertID& operator= (ASN1C__SeqOfESSCertID& srcData);
   void Append (ASN1T_ESSCertID * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SeqOfESSCertID (ASN1CTXT* pctxt,
   ASN1T__SeqOfESSCertID *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfESSCertID (ASN1CTXT* pctxt,
   ASN1T__SeqOfESSCertID *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SeqOfESSCertID
  (ASN1CTXT* pctxt, ASN1T__SeqOfESSCertID* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SeqOfESSCertID (ASN1CTXT *pctxt, ASN1T__SeqOfESSCertID* pSrcValue, ASN1T__SeqOfESSCertID* pDstValue);

EXTERN void asn1Free__SeqOfESSCertID (ASN1CTXT *pctxt, ASN1T__SeqOfESSCertID* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfPolicyInformation                                   */
/*                                                            */
/**************************************************************/

/* List of ASN1T_PolicyInformation */
typedef struct EXTERN ASN1T__SeqOfPolicyInformation : public ASN1TPDUSeqOfList {
   ~ASN1T__SeqOfPolicyInformation();
} ASN1T__SeqOfPolicyInformation;

class EXTERN ASN1C__SeqOfPolicyInformation :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SeqOfPolicyInformation& msgData;
   struct ASN1T_PolicyInformation *mpElement;
   class ASN1C_PolicyInformation* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SeqOfPolicyInformation (ASN1T__SeqOfPolicyInformation& data);
   ASN1C__SeqOfPolicyInformation (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfPolicyInformation& data);
   ASN1C__SeqOfPolicyInformation (ASN1C__SeqOfPolicyInformation& original);

   ~ASN1C__SeqOfPolicyInformation();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SeqOfPolicyInformation& getCopy (ASN1T__SeqOfPolicyInformation* pDstData = 0);
   ASN1T__SeqOfPolicyInformation* newCopy ();

   ASN1C__SeqOfPolicyInformation& operator= (ASN1C__SeqOfPolicyInformation& srcData);
   void Append (struct ASN1T_PolicyInformation * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SeqOfPolicyInformation (ASN1CTXT* pctxt,
   ASN1T__SeqOfPolicyInformation *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfPolicyInformation (ASN1CTXT* pctxt,
   ASN1T__SeqOfPolicyInformation *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SeqOfPolicyInformation
  (ASN1CTXT* pctxt, ASN1T__SeqOfPolicyInformation* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SeqOfPolicyInformation (ASN1CTXT *pctxt, ASN1T__SeqOfPolicyInformation* pSrcValue, ASN1T__SeqOfPolicyInformation* pDstValue);

EXTERN void asn1Free__SeqOfPolicyInformation (ASN1CTXT *pctxt, ASN1T__SeqOfPolicyInformation* pvalue);

/**************************************************************/
/*                                                            */
/*  SigningCertificate                                        */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SigningCertificate;

typedef struct EXTERN ASN1T_SigningCertificate : public ASN1TPDU {
   struct {
      unsigned policiesPresent : 1;
   } m;
   ASN1T__SeqOfESSCertID certs;
   ASN1T__SeqOfPolicyInformation policies;
   ASN1T_SigningCertificate ();
   ASN1T_SigningCertificate (ASN1C_SigningCertificate& srcData);
   ~ASN1T_SigningCertificate ();
} ASN1T_SigningCertificate;

class EXTERN ASN1C_SigningCertificate :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SigningCertificate& msgData;
   struct ElementID {
      enum {
         _unknown, certs, policies
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C__SeqOfESSCertID* mpCertsC;
   class ASN1C__SeqOfPolicyInformation* mpPoliciesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_SigningCertificate (ASN1T_SigningCertificate& data);
   ASN1C_SigningCertificate (
      ASN1MessageBufferIF& msgBuf, ASN1T_SigningCertificate& data);
   ASN1C_SigningCertificate (ASN1C_SigningCertificate& original);

   ~ASN1C_SigningCertificate();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_SigningCertificate& getCopy (ASN1T_SigningCertificate* pDstData = 0);
   ASN1T_SigningCertificate* newCopy ();

   inline ASN1C_SigningCertificate& operator= (ASN1C_SigningCertificate& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_SigningCertificate (ASN1CTXT* pctxt,
   ASN1T_SigningCertificate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SigningCertificate (ASN1CTXT* pctxt,
   ASN1T_SigningCertificate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SigningCertificate
  (ASN1CTXT* pctxt, ASN1T_SigningCertificate* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SigningCertificate (ASN1CTXT *pctxt, ASN1T_SigningCertificate* pSrcValue, ASN1T_SigningCertificate* pDstValue);

EXTERN void asn1Free_SigningCertificate (ASN1CTXT *pctxt, ASN1T_SigningCertificate* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherHashValue                                            */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_OtherHashValue;

class EXTERN ASN1C_OtherHashValue :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OtherHashValue& msgData;
public:
   ASN1C_OtherHashValue (ASN1T_OtherHashValue& data);
   ASN1C_OtherHashValue (
      ASN1MessageBufferIF& msgBuf, ASN1T_OtherHashValue& data);
   ASN1C_OtherHashValue (ASN1C_OtherHashValue& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OtherHashValue& getCopy (ASN1T_OtherHashValue* pDstData = 0);
   ASN1T_OtherHashValue* newCopy ();

   inline ASN1C_OtherHashValue& operator= (ASN1C_OtherHashValue& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_OtherHashValue (ASN1CTXT* pctxt,
   ASN1T_OtherHashValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherHashValue (ASN1CTXT* pctxt,
   ASN1T_OtherHashValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OtherHashValue
  (ASN1CTXT* pctxt, ASN1T_OtherHashValue* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OtherHashValue (ASN1CTXT *pctxt, ASN1T_OtherHashValue* pSrcValue, ASN1T_OtherHashValue* pDstValue);

EXTERN void asn1Free_OtherHashValue (ASN1CTXT *pctxt, ASN1T_OtherHashValue* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherHashAlgAndValue                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OtherHashAlgAndValue;

typedef struct EXTERN ASN1T_OtherHashAlgAndValue : public ASN1TPDU {
   ASN1T_AlgorithmIdentifier hashAlgorithm;
   ASN1T_OtherHashValue hashValue;
   ASN1T_OtherHashAlgAndValue ();
   ASN1T_OtherHashAlgAndValue (ASN1C_OtherHashAlgAndValue& srcData);
   ~ASN1T_OtherHashAlgAndValue ();
} ASN1T_OtherHashAlgAndValue;

class EXTERN ASN1C_OtherHashAlgAndValue :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OtherHashAlgAndValue& msgData;
   struct ElementID {
      enum {
         _unknown, hashAlgorithm, hashValue
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpHashAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_OtherHashAlgAndValue (ASN1T_OtherHashAlgAndValue& data);
   ASN1C_OtherHashAlgAndValue (
      ASN1MessageBufferIF& msgBuf, ASN1T_OtherHashAlgAndValue& data);
   ASN1C_OtherHashAlgAndValue (ASN1C_OtherHashAlgAndValue& original);

   ~ASN1C_OtherHashAlgAndValue();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OtherHashAlgAndValue& getCopy (ASN1T_OtherHashAlgAndValue* pDstData = 0);
   ASN1T_OtherHashAlgAndValue* newCopy ();

   inline ASN1C_OtherHashAlgAndValue& operator= (ASN1C_OtherHashAlgAndValue& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_OtherHashAlgAndValue (ASN1CTXT* pctxt,
   ASN1T_OtherHashAlgAndValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherHashAlgAndValue (ASN1CTXT* pctxt,
   ASN1T_OtherHashAlgAndValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OtherHashAlgAndValue
  (ASN1CTXT* pctxt, ASN1T_OtherHashAlgAndValue* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OtherHashAlgAndValue (ASN1CTXT *pctxt, ASN1T_OtherHashAlgAndValue* pSrcValue, ASN1T_OtherHashAlgAndValue* pDstValue);

EXTERN void asn1Free_OtherHashAlgAndValue (ASN1CTXT *pctxt, ASN1T_OtherHashAlgAndValue* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherHash                                                 */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_OtherHash_sha1Hash            1
#define T_OtherHash_otherHash           2

class EXTERN ASN1C_OtherHash;

typedef struct EXTERN ASN1T_OtherHash : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_OtherHashValue *sha1Hash;
      /* t = 2 */
      ASN1T_OtherHashAlgAndValue *otherHash;
   } u;
   ASN1T_OtherHash () {}
   ASN1T_OtherHash (ASN1C_OtherHash& srcData);
   ~ASN1T_OtherHash ();
} ASN1T_OtherHash;

class EXTERN ASN1C_OtherHash :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OtherHash& msgData;
   struct ElementID {
      enum {
         _unknown, sha1Hash, otherHash
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_OtherHashAlgAndValue* mpOtherHashC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_OtherHash (ASN1T_OtherHash& data);
   ASN1C_OtherHash (
      ASN1MessageBufferIF& msgBuf, ASN1T_OtherHash& data);
   ASN1C_OtherHash (ASN1C_OtherHash& original);

   ~ASN1C_OtherHash();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OtherHash& getCopy (ASN1T_OtherHash* pDstData = 0);
   ASN1T_OtherHash* newCopy ();

   inline ASN1C_OtherHash& operator= (ASN1C_OtherHash& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_OtherHash (ASN1CTXT* pctxt,
   ASN1T_OtherHash *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherHash (ASN1CTXT* pctxt,
   ASN1T_OtherHash *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OtherHash
  (ASN1CTXT* pctxt, ASN1T_OtherHash* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OtherHash (ASN1CTXT *pctxt, ASN1T_OtherHash* pSrcValue, ASN1T_OtherHash* pDstValue);

EXTERN void asn1Free_OtherHash (ASN1CTXT *pctxt, ASN1T_OtherHash* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherCertID                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OtherCertID;

typedef struct EXTERN ASN1T_OtherCertID : public ASN1TPDU {
   struct {
      unsigned issuerSerialPresent : 1;
   } m;
   ASN1T_OtherHash otherCertHash;
   ASN1T_IssuerSerial issuerSerial;
   ASN1T_OtherCertID ();
   ASN1T_OtherCertID (ASN1C_OtherCertID& srcData);
   ~ASN1T_OtherCertID ();
} ASN1T_OtherCertID;

class EXTERN ASN1C_OtherCertID :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OtherCertID& msgData;
   struct ElementID {
      enum {
         _unknown, otherCertHash, issuerSerial
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_OtherHash* mpOtherCertHashC;
   class ASN1C_IssuerSerial* mpIssuerSerialC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_OtherCertID (ASN1T_OtherCertID& data);
   ASN1C_OtherCertID (
      ASN1MessageBufferIF& msgBuf, ASN1T_OtherCertID& data);
   ASN1C_OtherCertID (ASN1C_OtherCertID& original);

   ~ASN1C_OtherCertID();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OtherCertID& getCopy (ASN1T_OtherCertID* pDstData = 0);
   ASN1T_OtherCertID* newCopy ();

   inline ASN1C_OtherCertID& operator= (ASN1C_OtherCertID& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_OtherCertID (ASN1CTXT* pctxt,
   ASN1T_OtherCertID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherCertID (ASN1CTXT* pctxt,
   ASN1T_OtherCertID *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OtherCertID
  (ASN1CTXT* pctxt, ASN1T_OtherCertID* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OtherCertID (ASN1CTXT *pctxt, ASN1T_OtherCertID* pSrcValue, ASN1T_OtherCertID* pDstValue);

EXTERN void asn1Free_OtherCertID (ASN1CTXT *pctxt, ASN1T_OtherCertID* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfOtherCertID                                         */
/*                                                            */
/**************************************************************/

/* List of ASN1T_OtherCertID */
typedef struct EXTERN ASN1T__SeqOfOtherCertID : public ASN1TPDUSeqOfList {
   ~ASN1T__SeqOfOtherCertID();
} ASN1T__SeqOfOtherCertID;

class EXTERN ASN1C__SeqOfOtherCertID :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SeqOfOtherCertID& msgData;
   ASN1T_OtherCertID *mpElement;
   class ASN1C_OtherCertID* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SeqOfOtherCertID (ASN1T__SeqOfOtherCertID& data);
   ASN1C__SeqOfOtherCertID (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfOtherCertID& data);
   ASN1C__SeqOfOtherCertID (ASN1C__SeqOfOtherCertID& original);

   ~ASN1C__SeqOfOtherCertID();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SeqOfOtherCertID& getCopy (ASN1T__SeqOfOtherCertID* pDstData = 0);
   ASN1T__SeqOfOtherCertID* newCopy ();

   ASN1C__SeqOfOtherCertID& operator= (ASN1C__SeqOfOtherCertID& srcData);
   void Append (ASN1T_OtherCertID * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SeqOfOtherCertID (ASN1CTXT* pctxt,
   ASN1T__SeqOfOtherCertID *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfOtherCertID (ASN1CTXT* pctxt,
   ASN1T__SeqOfOtherCertID *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SeqOfOtherCertID
  (ASN1CTXT* pctxt, ASN1T__SeqOfOtherCertID* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SeqOfOtherCertID (ASN1CTXT *pctxt, ASN1T__SeqOfOtherCertID* pSrcValue, ASN1T__SeqOfOtherCertID* pDstValue);

EXTERN void asn1Free__SeqOfOtherCertID (ASN1CTXT *pctxt, ASN1T__SeqOfOtherCertID* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherSigningCertificate                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OtherSigningCertificate;

typedef struct EXTERN ASN1T_OtherSigningCertificate : public ASN1TPDU {
   struct {
      unsigned policiesPresent : 1;
   } m;
   ASN1T__SeqOfOtherCertID certs;
   ASN1T__SeqOfPolicyInformation policies;
   ASN1T_OtherSigningCertificate ();
   ASN1T_OtherSigningCertificate (ASN1C_OtherSigningCertificate& srcData);
   ~ASN1T_OtherSigningCertificate ();
} ASN1T_OtherSigningCertificate;

class EXTERN ASN1C_OtherSigningCertificate :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_OtherSigningCertificate& msgData;
   struct ElementID {
      enum {
         _unknown, certs, policies
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C__SeqOfOtherCertID* mpCertsC;
   class ASN1C__SeqOfPolicyInformation* mpPoliciesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_OtherSigningCertificate (ASN1T_OtherSigningCertificate& data);
   ASN1C_OtherSigningCertificate (
      ASN1MessageBufferIF& msgBuf, ASN1T_OtherSigningCertificate& data);
   ASN1C_OtherSigningCertificate (ASN1C_OtherSigningCertificate& original);

   ~ASN1C_OtherSigningCertificate();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_OtherSigningCertificate& getCopy (ASN1T_OtherSigningCertificate* pDstData = 0);
   ASN1T_OtherSigningCertificate* newCopy ();

   inline ASN1C_OtherSigningCertificate& operator= (ASN1C_OtherSigningCertificate& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_OtherSigningCertificate (ASN1CTXT* pctxt,
   ASN1T_OtherSigningCertificate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherSigningCertificate (ASN1CTXT* pctxt,
   ASN1T_OtherSigningCertificate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OtherSigningCertificate
  (ASN1CTXT* pctxt, ASN1T_OtherSigningCertificate* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OtherSigningCertificate (ASN1CTXT *pctxt, ASN1T_OtherSigningCertificate* pSrcValue, ASN1T_OtherSigningCertificate* pDstValue);

EXTERN void asn1Free_OtherSigningCertificate (ASN1CTXT *pctxt, ASN1T_OtherSigningCertificate* pvalue);

/**************************************************************/
/*                                                            */
/*  Version                                                   */
/*                                                            */
/**************************************************************/

struct EXTERN Version {
   enum Root {
      v1 = 0,
      v2 = 1,
      v3 = 2
   } ;
} ;

typedef ASN1UINT ASN1T_Version;

class EXTERN ASN1C_Version :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Version& msgData;
public:
   ASN1C_Version (ASN1T_Version& data);
   ASN1C_Version (
      ASN1MessageBufferIF& msgBuf, ASN1T_Version& data);
   ASN1C_Version (ASN1C_Version& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Version& getCopy (ASN1T_Version* pDstData = 0);
   ASN1T_Version* newCopy ();

   inline ASN1C_Version& operator= (ASN1C_Version& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
   static int parseNamedValue (ASN1CTXT* pctxt, ASN1UINT* value);
} ;

EXTERN int asn1E_Version (ASN1CTXT* pctxt,
   ASN1T_Version *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Version (ASN1CTXT* pctxt,
   ASN1T_Version *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Version
  (ASN1CTXT* pctxt, ASN1T_Version value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Version (ASN1CTXT *pctxt, ASN1T_Version* pSrcValue, ASN1T_Version* pDstValue);

/**************************************************************/
/*                                                            */
/*  Validity                                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Validity;

typedef struct EXTERN ASN1T_Validity : public ASN1TPDU {
   ASN1T_Time notBefore;
   ASN1T_Time notAfter;
   ASN1T_Validity ();
   ASN1T_Validity (ASN1C_Validity& srcData);
   ~ASN1T_Validity ();
} ASN1T_Validity;

class EXTERN ASN1C_Validity :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Validity& msgData;
   struct ElementID {
      enum {
         _unknown, notBefore, notAfter
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Time* mpNotBeforeC;
   class ASN1C_Time* mpNotAfterC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_Validity (ASN1T_Validity& data);
   ASN1C_Validity (
      ASN1MessageBufferIF& msgBuf, ASN1T_Validity& data);
   ASN1C_Validity (ASN1C_Validity& original);

   ~ASN1C_Validity();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Validity& getCopy (ASN1T_Validity* pDstData = 0);
   ASN1T_Validity* newCopy ();

   inline ASN1C_Validity& operator= (ASN1C_Validity& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Validity (ASN1CTXT* pctxt,
   ASN1T_Validity *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Validity (ASN1CTXT* pctxt,
   ASN1T_Validity *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Validity
  (ASN1CTXT* pctxt, ASN1T_Validity* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Validity (ASN1CTXT *pctxt, ASN1T_Validity* pSrcValue, ASN1T_Validity* pDstValue);

EXTERN void asn1Free_Validity (ASN1CTXT *pctxt, ASN1T_Validity* pvalue);

/**************************************************************/
/*                                                            */
/*  Attribute_values                                          */
/*                                                            */
/**************************************************************/

/* List of Asn1TObject */
typedef struct EXTERN ASN1T_Attribute_values : public ASN1TPDUSeqOfList {
   ~ASN1T_Attribute_values();
} ASN1T_Attribute_values;

class EXTERN ASN1C_Attribute_values :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Attribute_values& msgData;
   Asn1TObject *mpElement;
   class ASN1CXerOpenType* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_Attribute_values (ASN1T_Attribute_values& data);
   ASN1C_Attribute_values (
      ASN1MessageBufferIF& msgBuf, ASN1T_Attribute_values& data);
   ASN1C_Attribute_values (ASN1C_Attribute_values& original);

   ~ASN1C_Attribute_values();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Attribute_values& getCopy (ASN1T_Attribute_values* pDstData = 0);
   ASN1T_Attribute_values* newCopy ();

   ASN1C_Attribute_values& operator= (ASN1C_Attribute_values& srcData);
   void Append (Asn1TObject * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Attribute_values (ASN1CTXT* pctxt,
   ASN1T_Attribute_values *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Attribute_values (ASN1CTXT* pctxt,
   ASN1T_Attribute_values *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Attribute_values
  (ASN1CTXT* pctxt, ASN1T_Attribute_values* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Attribute_values (ASN1CTXT *pctxt, ASN1T_Attribute_values* pSrcValue, ASN1T_Attribute_values* pDstValue);

EXTERN void asn1Free_Attribute_values (ASN1CTXT *pctxt, ASN1T_Attribute_values* pvalue);

/**************************************************************/
/*                                                            */
/*  Attribute                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Attribute;

typedef struct EXTERN ASN1T_Attribute : public ASN1TPDU {
   ASN1TObjId type;
   ASN1T_Attribute_values values;
   ASN1T_Attribute ();
   ASN1T_Attribute (ASN1C_Attribute& srcData);
   ~ASN1T_Attribute ();
} ASN1T_Attribute;

class EXTERN ASN1C_Attribute :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Attribute& msgData;
   struct ElementID {
      enum {
         _unknown, type, values
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Attribute_values* mpValuesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_Attribute (ASN1T_Attribute& data);
   ASN1C_Attribute (
      ASN1MessageBufferIF& msgBuf, ASN1T_Attribute& data);
   ASN1C_Attribute (ASN1C_Attribute& original);

   ~ASN1C_Attribute();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Attribute& getCopy (ASN1T_Attribute* pDstData = 0);
   ASN1T_Attribute* newCopy ();

   inline ASN1C_Attribute& operator= (ASN1C_Attribute& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Attribute (ASN1CTXT* pctxt,
   ASN1T_Attribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Attribute (ASN1CTXT* pctxt,
   ASN1T_Attribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Attribute
  (ASN1CTXT* pctxt, ASN1T_Attribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN int asn1XETC_Attribute (ASN1CTXT* pctxt,
    ASN1T_Attribute *pvalue);

EXTERN int asn1XDTC_Attribute (ASN1CtxtPtr& pctxt,
    ASN1T_Attribute *pvalue);

EXTERN int asn1ETC_Attribute (ASN1CTXT* pctxt,
   ASN1T_Attribute *pvalue);

EXTERN int asn1DTC_Attribute (ASN1CTXT* pctxt,
   ASN1T_Attribute *pvalue);

EXTERN void asn1Copy_Attribute (ASN1CTXT *pctxt, ASN1T_Attribute* pSrcValue, ASN1T_Attribute* pDstValue);

EXTERN void asn1Free_Attribute (ASN1CTXT *pctxt, ASN1T_Attribute* pvalue);

/**************************************************************/
/*                                                            */
/*  TBSCertList_revokedCertificates_element                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TBSCertList_revokedCertificates_element;

typedef struct EXTERN ASN1T_TBSCertList_revokedCertificates_element : public ASN1TPDU {
   struct {
      unsigned crlEntryExtensionsPresent : 1;
   } m;
   ASN1T_CertificateSerialNumber userCertificate;
   ASN1T_Time revocationDate;
   ASN1TSeqOfList crlEntryExtensions;
   ASN1T_TBSCertList_revokedCertificates_element ();
   ASN1T_TBSCertList_revokedCertificates_element (ASN1C_TBSCertList_revokedCertificates_element& srcData);
   ~ASN1T_TBSCertList_revokedCertificates_element ();
} ASN1T_TBSCertList_revokedCertificates_element;

class EXTERN ASN1C_TBSCertList_revokedCertificates_element :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TBSCertList_revokedCertificates_element& msgData;
   struct ElementID {
      enum {
         _unknown, userCertificate, revocationDate, crlEntryExtensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Time* mpRevocationDateC;
   class ASN1C_Extensions* mpCrlEntryExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_TBSCertList_revokedCertificates_element (ASN1T_TBSCertList_revokedCertificates_element& data);
   ASN1C_TBSCertList_revokedCertificates_element (
      ASN1MessageBufferIF& msgBuf, ASN1T_TBSCertList_revokedCertificates_element& data);
   ASN1C_TBSCertList_revokedCertificates_element (ASN1C_TBSCertList_revokedCertificates_element& original);

   ~ASN1C_TBSCertList_revokedCertificates_element();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TBSCertList_revokedCertificates_element& getCopy (ASN1T_TBSCertList_revokedCertificates_element* pDstData = 0);
   ASN1T_TBSCertList_revokedCertificates_element* newCopy ();

   inline ASN1C_TBSCertList_revokedCertificates_element& operator= (ASN1C_TBSCertList_revokedCertificates_element& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TBSCertList_revokedCertificates_element (ASN1CTXT* pctxt,
   ASN1T_TBSCertList_revokedCertificates_element *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TBSCertList_revokedCertificates_element (ASN1CTXT* pctxt,
   ASN1T_TBSCertList_revokedCertificates_element *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TBSCertList_revokedCertificates_element
  (ASN1CTXT* pctxt, ASN1T_TBSCertList_revokedCertificates_element* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TBSCertList_revokedCertificates_element (ASN1CTXT *pctxt, ASN1T_TBSCertList_revokedCertificates_element* pSrcValue, ASN1T_TBSCertList_revokedCertificates_element* pDstValue);

EXTERN void asn1Free_TBSCertList_revokedCertificates_element (ASN1CTXT *pctxt, ASN1T_TBSCertList_revokedCertificates_element* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfTBSCertList_revokedCertificates_element             */
/*                                                            */
/**************************************************************/

/* List of ASN1T_TBSCertList_revokedCertificates_element */
typedef struct EXTERN ASN1T__SeqOfTBSCertList_revokedCertificates_element : public ASN1TPDUSeqOfList {
   ~ASN1T__SeqOfTBSCertList_revokedCertificates_element();
} ASN1T__SeqOfTBSCertList_revokedCertificates_element;

class EXTERN ASN1C__SeqOfTBSCertList_revokedCertificates_element :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SeqOfTBSCertList_revokedCertificates_element& msgData;
   ASN1T_TBSCertList_revokedCertificates_element *mpElement;
   class ASN1C_TBSCertList_revokedCertificates_element* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SeqOfTBSCertList_revokedCertificates_element (ASN1T__SeqOfTBSCertList_revokedCertificates_element& data);
   ASN1C__SeqOfTBSCertList_revokedCertificates_element (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfTBSCertList_revokedCertificates_element& data);
   ASN1C__SeqOfTBSCertList_revokedCertificates_element (ASN1C__SeqOfTBSCertList_revokedCertificates_element& original);

   ~ASN1C__SeqOfTBSCertList_revokedCertificates_element();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SeqOfTBSCertList_revokedCertificates_element& getCopy (ASN1T__SeqOfTBSCertList_revokedCertificates_element* pDstData = 0);
   ASN1T__SeqOfTBSCertList_revokedCertificates_element* newCopy ();

   ASN1C__SeqOfTBSCertList_revokedCertificates_element& operator= (ASN1C__SeqOfTBSCertList_revokedCertificates_element& srcData);
   void Append (ASN1T_TBSCertList_revokedCertificates_element * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SeqOfTBSCertList_revokedCertificates_element (ASN1CTXT* pctxt,
   ASN1T__SeqOfTBSCertList_revokedCertificates_element *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfTBSCertList_revokedCertificates_element (ASN1CTXT* pctxt,
   ASN1T__SeqOfTBSCertList_revokedCertificates_element *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SeqOfTBSCertList_revokedCertificates_element
  (ASN1CTXT* pctxt, ASN1T__SeqOfTBSCertList_revokedCertificates_element* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SeqOfTBSCertList_revokedCertificates_element (ASN1CTXT *pctxt, ASN1T__SeqOfTBSCertList_revokedCertificates_element* pSrcValue, ASN1T__SeqOfTBSCertList_revokedCertificates_element* pDstValue);

EXTERN void asn1Free__SeqOfTBSCertList_revokedCertificates_element (ASN1CTXT *pctxt, ASN1T__SeqOfTBSCertList_revokedCertificates_element* pvalue);

/**************************************************************/
/*                                                            */
/*  TBSCertList                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TBSCertList;

typedef struct EXTERN ASN1T_TBSCertList : public ASN1TPDU {
   struct {
      unsigned versionPresent : 1;
      unsigned nextUpdatePresent : 1;
      unsigned revokedCertificatesPresent : 1;
      unsigned crlExtensionsPresent : 1;
   } m;
   ASN1T_Version version;
   ASN1T_AlgorithmIdentifier signature;
   ASN1T_Name issuer;
   ASN1T_Time thisUpdate;
   ASN1T_Time nextUpdate;
   ASN1T__SeqOfTBSCertList_revokedCertificates_element revokedCertificates;
   ASN1TSeqOfList crlExtensions;
   ASN1T_TBSCertList ();
   ASN1T_TBSCertList (ASN1C_TBSCertList& srcData);
   ~ASN1T_TBSCertList ();
} ASN1T_TBSCertList;

class EXTERN ASN1C_TBSCertList :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TBSCertList& msgData;
   struct ElementID {
      enum {
         _unknown, version, signature, issuer, thisUpdate, nextUpdate,
         revokedCertificates, crlExtensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpSignatureC;
   class ASN1C_Name* mpIssuerC;
   class ASN1C_Time* mpThisUpdateC;
   class ASN1C_Time* mpNextUpdateC;
   class ASN1C__SeqOfTBSCertList_revokedCertificates_element* mpRevokedCertificatesC;
   class ASN1C_Extensions* mpCrlExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_TBSCertList (ASN1T_TBSCertList& data);
   ASN1C_TBSCertList (
      ASN1MessageBufferIF& msgBuf, ASN1T_TBSCertList& data);
   ASN1C_TBSCertList (ASN1C_TBSCertList& original);

   ~ASN1C_TBSCertList();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TBSCertList& getCopy (ASN1T_TBSCertList* pDstData = 0);
   ASN1T_TBSCertList* newCopy ();

   inline ASN1C_TBSCertList& operator= (ASN1C_TBSCertList& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TBSCertList (ASN1CTXT* pctxt,
   ASN1T_TBSCertList *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TBSCertList (ASN1CTXT* pctxt,
   ASN1T_TBSCertList *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TBSCertList
  (ASN1CTXT* pctxt, ASN1T_TBSCertList* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TBSCertList (ASN1CTXT *pctxt, ASN1T_TBSCertList* pSrcValue, ASN1T_TBSCertList* pDstValue);

EXTERN void asn1Free_TBSCertList (ASN1CTXT *pctxt, ASN1T_TBSCertList* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateList                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificateList;

typedef struct EXTERN ASN1T_CertificateList : public ASN1TPDU {
   ASN1T_TBSCertList tbsCertList;
   ASN1T_AlgorithmIdentifier signatureAlgorithm;
   ASN1TDynBitStr signature;
   ASN1T_CertificateList ();
   ASN1T_CertificateList (ASN1C_CertificateList& srcData);
   ~ASN1T_CertificateList ();
} ASN1T_CertificateList;

class EXTERN ASN1C_CertificateList :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificateList& msgData;
   struct ElementID {
      enum {
         _unknown, tbsCertList, signatureAlgorithm, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_TBSCertList* mpTbsCertListC;
   class ASN1C_AlgorithmIdentifier* mpSignatureAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertificateList (ASN1T_CertificateList& data);
   ASN1C_CertificateList (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateList& data);
   ASN1C_CertificateList (ASN1C_CertificateList& original);

   ~ASN1C_CertificateList();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CertificateList& getCopy (ASN1T_CertificateList* pDstData = 0);
   ASN1T_CertificateList* newCopy ();

   inline ASN1C_CertificateList& operator= (ASN1C_CertificateList& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_CertificateList (ASN1CTXT* pctxt,
   ASN1T_CertificateList *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateList (ASN1CTXT* pctxt,
   ASN1T_CertificateList *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateList
  (ASN1CTXT* pctxt, ASN1T_CertificateList* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateList (ASN1CTXT *pctxt, ASN1T_CertificateList* pSrcValue, ASN1T_CertificateList* pDstValue);

EXTERN void asn1Free_CertificateList (ASN1CTXT *pctxt, ASN1T_CertificateList* pvalue);

/**************************************************************/
/*                                                            */
/*  Extension                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Extension;

typedef struct EXTERN ASN1T_Extension : public ASN1TPDU {
   ASN1TObjId extnID;
   ASN1BOOL critical;
   ASN1TDynOctStr extnValue;
   Asn1TObject value;
   ASN1T_Extension ();
   ASN1T_Extension (ASN1C_Extension& srcData);
   ~ASN1T_Extension ();
} ASN1T_Extension;

class EXTERN ASN1C_Extension :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1CXerOpenType* mpValueC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1T_Extension& msgData;
   struct ElementID {
      enum {
         _unknown, extnID, critical, extnValue
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_Extension (ASN1T_Extension& data);
   ASN1C_Extension (
      ASN1MessageBufferIF& msgBuf, ASN1T_Extension& data);
   ASN1C_Extension (ASN1C_Extension& original);
   ~ASN1C_Extension();

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Extension& getCopy (ASN1T_Extension* pDstData = 0);
   ASN1T_Extension* newCopy ();

   inline ASN1C_Extension& operator= (ASN1C_Extension& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Extension (ASN1CTXT* pctxt,
   ASN1T_Extension *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Extension (ASN1CTXT* pctxt,
   ASN1T_Extension *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Extension
  (ASN1CTXT* pctxt, ASN1T_Extension* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN int asn1XETC_Extension (ASN1CTXT* pctxt,
    ASN1T_Extension *pvalue);

EXTERN int asn1XDTC_Extension (ASN1CtxtPtr& pctxt,
    ASN1T_Extension *pvalue);

EXTERN int asn1ETC_Extension (ASN1CTXT* pctxt,
   ASN1T_Extension *pvalue);

EXTERN int asn1DTC_Extension (ASN1CTXT* pctxt,
   ASN1T_Extension *pvalue);

EXTERN void asn1Copy_Extension (ASN1CTXT *pctxt, ASN1T_Extension* pSrcValue, ASN1T_Extension* pDstValue);

EXTERN void asn1Free_Extension (ASN1CTXT *pctxt, ASN1T_Extension* pvalue);

/**************************************************************/
/*                                                            */
/*  Extensions                                                */
/*                                                            */
/**************************************************************/

/* List of ASN1T_Extension */
typedef struct EXTERN ASN1T_Extensions : public ASN1TPDUSeqOfList {
   ~ASN1T_Extensions();
} ASN1T_Extensions;

class EXTERN ASN1C_Extensions :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Extensions& msgData;
   ASN1T_Extension *mpElement;
   class ASN1C_Extension* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_Extensions (ASN1T_Extensions& data);
   ASN1C_Extensions (
      ASN1MessageBufferIF& msgBuf, ASN1T_Extensions& data);
   ASN1C_Extensions (ASN1C_Extensions& original);

   ~ASN1C_Extensions();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Extensions& getCopy (ASN1T_Extensions* pDstData = 0);
   ASN1T_Extensions* newCopy ();

   ASN1C_Extensions& operator= (ASN1C_Extensions& srcData);
   void Append (ASN1T_Extension * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Extensions (ASN1CTXT* pctxt,
   ASN1T_Extensions *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Extensions (ASN1CTXT* pctxt,
   ASN1T_Extensions *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Extensions
  (ASN1CTXT* pctxt, ASN1T_Extensions* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Extensions (ASN1CTXT *pctxt, ASN1T_Extensions* pSrcValue, ASN1T_Extensions* pDstValue);

EXTERN void asn1Free_Extensions (ASN1CTXT *pctxt, ASN1T_Extensions* pvalue);

/**************************************************************/
/*                                                            */
/*  TBSCertificate                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TBSCertificate;

typedef struct EXTERN ASN1T_TBSCertificate : public ASN1TPDU {
   struct {
      unsigned versionPresent : 1;
      unsigned issuerUniqueIDPresent : 1;
      unsigned subjectUniqueIDPresent : 1;
      unsigned extensionsPresent : 1;
   } m;
   ASN1T_Version version;
   ASN1T_CertificateSerialNumber serialNumber;
   ASN1T_AlgorithmIdentifier signature;
   ASN1T_Name issuer;
   ASN1T_Validity validity;
   ASN1T_Name subject;
   ASN1T_SubjectPublicKeyInfo subjectPublicKeyInfo;
   ASN1T_UniqueIdentifier issuerUniqueID;
   ASN1T_UniqueIdentifier subjectUniqueID;
   ASN1T_Extensions extensions;
   ASN1T_TBSCertificate ();
   ASN1T_TBSCertificate (ASN1C_TBSCertificate& srcData);
   ~ASN1T_TBSCertificate ();
} ASN1T_TBSCertificate;

class EXTERN ASN1C_TBSCertificate :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TBSCertificate& msgData;
   struct ElementID {
      enum {
         _unknown, version, serialNumber, signature, issuer, validity,
         subject, subjectPublicKeyInfo, issuerUniqueID, subjectUniqueID,
         extensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpSignatureC;
   class ASN1C_Name* mpIssuerC;
   class ASN1C_Validity* mpValidityC;
   class ASN1C_Name* mpSubjectC;
   class ASN1C_SubjectPublicKeyInfo* mpSubjectPublicKeyInfoC;
   class ASN1C_Extensions* mpExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_TBSCertificate (ASN1T_TBSCertificate& data);
   ASN1C_TBSCertificate (
      ASN1MessageBufferIF& msgBuf, ASN1T_TBSCertificate& data);
   ASN1C_TBSCertificate (ASN1C_TBSCertificate& original);

   ~ASN1C_TBSCertificate();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TBSCertificate& getCopy (ASN1T_TBSCertificate* pDstData = 0);
   ASN1T_TBSCertificate* newCopy ();

   inline ASN1C_TBSCertificate& operator= (ASN1C_TBSCertificate& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TBSCertificate (ASN1CTXT* pctxt,
   ASN1T_TBSCertificate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TBSCertificate (ASN1CTXT* pctxt,
   ASN1T_TBSCertificate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TBSCertificate
  (ASN1CTXT* pctxt, ASN1T_TBSCertificate* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TBSCertificate (ASN1CTXT *pctxt, ASN1T_TBSCertificate* pSrcValue, ASN1T_TBSCertificate* pDstValue);

EXTERN void asn1Free_TBSCertificate (ASN1CTXT *pctxt, ASN1T_TBSCertificate* pvalue);

/**************************************************************/
/*                                                            */
/*  Certificate                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Certificate;

typedef struct EXTERN ASN1T_Certificate : public ASN1TPDU {
   ASN1T_TBSCertificate tbsCertificate;
   ASN1T_AlgorithmIdentifier signatureAlgorithm;
   ASN1TDynBitStr signature;
   ASN1T_Certificate ();
   ASN1T_Certificate (ASN1C_Certificate& srcData);
   ~ASN1T_Certificate ();
} ASN1T_Certificate;

class EXTERN ASN1C_Certificate :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Certificate& msgData;
   struct ElementID {
      enum {
         _unknown, tbsCertificate, signatureAlgorithm, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_TBSCertificate* mpTbsCertificateC;
   class ASN1C_AlgorithmIdentifier* mpSignatureAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_Certificate (ASN1T_Certificate& data);
   ASN1C_Certificate (
      ASN1MessageBufferIF& msgBuf, ASN1T_Certificate& data);
   ASN1C_Certificate (ASN1C_Certificate& original);

   ~ASN1C_Certificate();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_Certificate& getCopy (ASN1T_Certificate* pDstData = 0);
   ASN1T_Certificate* newCopy ();

   inline ASN1C_Certificate& operator= (ASN1C_Certificate& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_Certificate (ASN1CTXT* pctxt,
   ASN1T_Certificate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Certificate (ASN1CTXT* pctxt,
   ASN1T_Certificate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Certificate
  (ASN1CTXT* pctxt, ASN1T_Certificate* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Certificate (ASN1CTXT *pctxt, ASN1T_Certificate* pSrcValue, ASN1T_Certificate* pDstValue);

EXTERN void asn1Free_Certificate (ASN1CTXT *pctxt, ASN1T_Certificate* pvalue);

/**************************************************************/
/*                                                            */
/*  ESSCertIDv2                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ESSCertIDv2;

typedef struct EXTERN ASN1T_ESSCertIDv2 : public ASN1TPDU {
   struct {
      unsigned hashAlgorithmPresent : 1;
      unsigned issuerSerialPresent : 1;
   } m;
   ASN1T_AlgorithmIdentifier hashAlgorithm;
   ASN1T_CertHash certHash;
   ASN1T_IssuerSerial issuerSerial;
   ASN1T_ESSCertIDv2 ();
   ASN1T_ESSCertIDv2 (ASN1C_ESSCertIDv2& srcData);
   ~ASN1T_ESSCertIDv2 ();
} ASN1T_ESSCertIDv2;

class EXTERN ASN1C_ESSCertIDv2 :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ESSCertIDv2& msgData;
   struct ElementID {
      enum {
         _unknown, hashAlgorithm, certHash, issuerSerial
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpHashAlgorithmC;
   class ASN1C_IssuerSerial* mpIssuerSerialC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_ESSCertIDv2 (ASN1T_ESSCertIDv2& data);
   ASN1C_ESSCertIDv2 (
      ASN1MessageBufferIF& msgBuf, ASN1T_ESSCertIDv2& data);
   ASN1C_ESSCertIDv2 (ASN1C_ESSCertIDv2& original);

   ~ASN1C_ESSCertIDv2();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ESSCertIDv2& getCopy (ASN1T_ESSCertIDv2* pDstData = 0);
   ASN1T_ESSCertIDv2* newCopy ();

   inline ASN1C_ESSCertIDv2& operator= (ASN1C_ESSCertIDv2& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ESSCertIDv2 (ASN1CTXT* pctxt,
   ASN1T_ESSCertIDv2 *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESSCertIDv2 (ASN1CTXT* pctxt,
   ASN1T_ESSCertIDv2 *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ESSCertIDv2
  (ASN1CTXT* pctxt, ASN1T_ESSCertIDv2* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ESSCertIDv2 (ASN1CTXT *pctxt, ASN1T_ESSCertIDv2* pSrcValue, ASN1T_ESSCertIDv2* pDstValue);

EXTERN void asn1Free_ESSCertIDv2 (ASN1CTXT *pctxt, ASN1T_ESSCertIDv2* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfESSCertIDv2                                         */
/*                                                            */
/**************************************************************/

/* List of ASN1T_ESSCertIDv2 */
typedef struct EXTERN ASN1T__SeqOfESSCertIDv2 : public ASN1TPDUSeqOfList {
   ~ASN1T__SeqOfESSCertIDv2();
} ASN1T__SeqOfESSCertIDv2;

class EXTERN ASN1C__SeqOfESSCertIDv2 :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SeqOfESSCertIDv2& msgData;
   ASN1T_ESSCertIDv2 *mpElement;
   class ASN1C_ESSCertIDv2* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SeqOfESSCertIDv2 (ASN1T__SeqOfESSCertIDv2& data);
   ASN1C__SeqOfESSCertIDv2 (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfESSCertIDv2& data);
   ASN1C__SeqOfESSCertIDv2 (ASN1C__SeqOfESSCertIDv2& original);

   ~ASN1C__SeqOfESSCertIDv2();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SeqOfESSCertIDv2& getCopy (ASN1T__SeqOfESSCertIDv2* pDstData = 0);
   ASN1T__SeqOfESSCertIDv2* newCopy ();

   ASN1C__SeqOfESSCertIDv2& operator= (ASN1C__SeqOfESSCertIDv2& srcData);
   void Append (ASN1T_ESSCertIDv2 * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SeqOfESSCertIDv2 (ASN1CTXT* pctxt,
   ASN1T__SeqOfESSCertIDv2 *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfESSCertIDv2 (ASN1CTXT* pctxt,
   ASN1T__SeqOfESSCertIDv2 *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SeqOfESSCertIDv2
  (ASN1CTXT* pctxt, ASN1T__SeqOfESSCertIDv2* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SeqOfESSCertIDv2 (ASN1CTXT *pctxt, ASN1T__SeqOfESSCertIDv2* pSrcValue, ASN1T__SeqOfESSCertIDv2* pDstValue);

EXTERN void asn1Free__SeqOfESSCertIDv2 (ASN1CTXT *pctxt, ASN1T__SeqOfESSCertIDv2* pvalue);

/**************************************************************/
/*                                                            */
/*  SigningCertificateV2                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SigningCertificateV2;

typedef struct EXTERN ASN1T_SigningCertificateV2 : public ASN1TPDU {
   struct {
      unsigned policiesPresent : 1;
   } m;
   ASN1T__SeqOfESSCertIDv2 certs;
   ASN1T__SeqOfPolicyInformation policies;
   ASN1T_SigningCertificateV2 ();
   ASN1T_SigningCertificateV2 (ASN1C_SigningCertificateV2& srcData);
   ~ASN1T_SigningCertificateV2 ();
} ASN1T_SigningCertificateV2;

class EXTERN ASN1C_SigningCertificateV2 :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SigningCertificateV2& msgData;
   struct ElementID {
      enum {
         _unknown, certs, policies
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C__SeqOfESSCertIDv2* mpCertsC;
   class ASN1C__SeqOfPolicyInformation* mpPoliciesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_SigningCertificateV2 (ASN1T_SigningCertificateV2& data);
   ASN1C_SigningCertificateV2 (
      ASN1MessageBufferIF& msgBuf, ASN1T_SigningCertificateV2& data);
   ASN1C_SigningCertificateV2 (ASN1C_SigningCertificateV2& original);

   ~ASN1C_SigningCertificateV2();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_SigningCertificateV2& getCopy (ASN1T_SigningCertificateV2* pDstData = 0);
   ASN1T_SigningCertificateV2* newCopy ();

   inline ASN1C_SigningCertificateV2& operator= (ASN1C_SigningCertificateV2& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_SigningCertificateV2 (ASN1CTXT* pctxt,
   ASN1T_SigningCertificateV2 *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SigningCertificateV2 (ASN1CTXT* pctxt,
   ASN1T_SigningCertificateV2 *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SigningCertificateV2
  (ASN1CTXT* pctxt, ASN1T_SigningCertificateV2* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SigningCertificateV2 (ASN1CTXT *pctxt, ASN1T_SigningCertificateV2* pSrcValue, ASN1T_SigningCertificateV2* pDstValue);

EXTERN void asn1Free_SigningCertificateV2 (ASN1CTXT *pctxt, ASN1T_SigningCertificateV2* pvalue);

/**************************************************************/
/*                                                            */
/*  DigestAlgorithmIdentifier                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DigestAlgorithmIdentifier;

typedef ASN1T_AlgorithmIdentifier ASN1T_DigestAlgorithmIdentifier;

class EXTERN ASN1C_DigestAlgorithmIdentifier :
   public ASN1C_AlgorithmIdentifier
{
protected:
public:
   ASN1C_DigestAlgorithmIdentifier (ASN1T_DigestAlgorithmIdentifier& data);
   ASN1C_DigestAlgorithmIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_DigestAlgorithmIdentifier& data);
   ASN1C_DigestAlgorithmIdentifier (ASN1C_DigestAlgorithmIdentifier& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_DigestAlgorithmIdentifier& getCopy (ASN1T_DigestAlgorithmIdentifier* pDstData = 0);
   ASN1T_DigestAlgorithmIdentifier* newCopy ();

   inline ASN1C_DigestAlgorithmIdentifier& operator= (ASN1C_DigestAlgorithmIdentifier& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_DigestAlgorithmIdentifier (ASN1CTXT* pctxt,
   ASN1T_DigestAlgorithmIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DigestAlgorithmIdentifier (ASN1CTXT* pctxt,
   ASN1T_DigestAlgorithmIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DigestAlgorithmIdentifier
  (ASN1CTXT* pctxt, ASN1T_DigestAlgorithmIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DigestAlgorithmIdentifier (ASN1CTXT *pctxt, ASN1T_DigestAlgorithmIdentifier* pSrcValue, ASN1T_DigestAlgorithmIdentifier* pDstValue);

EXTERN void asn1Free_DigestAlgorithmIdentifier (ASN1CTXT *pctxt, ASN1T_DigestAlgorithmIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  DigestInfo                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DigestInfo;

typedef struct EXTERN ASN1T_DigestInfo : public ASN1TPDU {
   ASN1T_DigestAlgorithmIdentifier digestAlgorithm;
   ASN1TDynOctStr digest;
   ASN1T_DigestInfo ();
   ASN1T_DigestInfo (ASN1C_DigestInfo& srcData);
   ~ASN1T_DigestInfo ();
} ASN1T_DigestInfo;

class EXTERN ASN1C_DigestInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DigestInfo& msgData;
   struct ElementID {
      enum {
         _unknown, digestAlgorithm, digest
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DigestAlgorithmIdentifier* mpDigestAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_DigestInfo (ASN1T_DigestInfo& data);
   ASN1C_DigestInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_DigestInfo& data);
   ASN1C_DigestInfo (ASN1C_DigestInfo& original);

   ~ASN1C_DigestInfo();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_DigestInfo& getCopy (ASN1T_DigestInfo* pDstData = 0);
   ASN1T_DigestInfo* newCopy ();

   inline ASN1C_DigestInfo& operator= (ASN1C_DigestInfo& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_DigestInfo (ASN1CTXT* pctxt,
   ASN1T_DigestInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DigestInfo (ASN1CTXT* pctxt,
   ASN1T_DigestInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DigestInfo
  (ASN1CTXT* pctxt, ASN1T_DigestInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DigestInfo (ASN1CTXT *pctxt, ASN1T_DigestInfo* pSrcValue, ASN1T_DigestInfo* pDstValue);

EXTERN void asn1Free_DigestInfo (ASN1CTXT *pctxt, ASN1T_DigestInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  SignedOpenType                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SignedOpenType;

typedef struct EXTERN ASN1T_SignedOpenType : public ASN1TPDU {
   ASN1TOpenType tbsCertificate;
   ASN1T_AlgorithmIdentifier signatureAlgorithm;
   ASN1TDynBitStr signature;
   ASN1T_SignedOpenType ();
   ASN1T_SignedOpenType (ASN1C_SignedOpenType& srcData);
   ~ASN1T_SignedOpenType ();
} ASN1T_SignedOpenType;

class EXTERN ASN1C_SignedOpenType :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SignedOpenType& msgData;
   struct ElementID {
      enum {
         _unknown, tbsCertificate, signatureAlgorithm, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1CXerOpenType* mpTbsCertificateC;
   class ASN1C_AlgorithmIdentifier* mpSignatureAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_SignedOpenType (ASN1T_SignedOpenType& data);
   ASN1C_SignedOpenType (
      ASN1MessageBufferIF& msgBuf, ASN1T_SignedOpenType& data);
   ASN1C_SignedOpenType (ASN1C_SignedOpenType& original);

   ~ASN1C_SignedOpenType();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_SignedOpenType& getCopy (ASN1T_SignedOpenType* pDstData = 0);
   ASN1T_SignedOpenType* newCopy ();

   inline ASN1C_SignedOpenType& operator= (ASN1C_SignedOpenType& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_SignedOpenType (ASN1CTXT* pctxt,
   ASN1T_SignedOpenType *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignedOpenType (ASN1CTXT* pctxt,
   ASN1T_SignedOpenType *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SignedOpenType
  (ASN1CTXT* pctxt, ASN1T_SignedOpenType* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SignedOpenType (ASN1CTXT *pctxt, ASN1T_SignedOpenType* pSrcValue, ASN1T_SignedOpenType* pDstValue);

EXTERN void asn1Free_SignedOpenType (ASN1CTXT *pctxt, ASN1T_SignedOpenType* pvalue);

/**************************************************************/
/*                                                            */
/*  _unstructuredName_Type                                    */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__unstructuredName_Type_utf8String 1
#define T__unstructuredName_Type_numericString 2
#define T__unstructuredName_Type_printableString 3
#define T__unstructuredName_Type_teletexString 4
#define T__unstructuredName_Type_ia5String 5
#define T__unstructuredName_Type_universalString 6
#define T__unstructuredName_Type_bmpString 7

class EXTERN ASN1C__unstructuredName_Type;

typedef struct EXTERN ASN1T__unstructuredName_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1NumericString numericString;
      /* t = 3 */
      ASN1PrintableString printableString;
      /* t = 4 */
      ASN1T61String teletexString;
      /* t = 5 */
      ASN1IA5String ia5String;
      /* t = 6 */
      ASN1UniversalString universalString;
      /* t = 7 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__unstructuredName_Type () {}
   ASN1T__unstructuredName_Type (ASN1C__unstructuredName_Type& srcData);
   ~ASN1T__unstructuredName_Type ();
} ASN1T__unstructuredName_Type;

class EXTERN ASN1C__unstructuredName_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__unstructuredName_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, numericString, printableString, teletexString,
         ia5String, universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__unstructuredName_Type (ASN1T__unstructuredName_Type& data);
   ASN1C__unstructuredName_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__unstructuredName_Type& data);
   ASN1C__unstructuredName_Type (ASN1C__unstructuredName_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__unstructuredName_Type& getCopy (ASN1T__unstructuredName_Type* pDstData = 0);
   ASN1T__unstructuredName_Type* newCopy ();

   inline ASN1C__unstructuredName_Type& operator= (ASN1C__unstructuredName_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__unstructuredName_Type (ASN1CTXT* pctxt,
   ASN1T__unstructuredName_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__unstructuredName_Type (ASN1CTXT* pctxt,
   ASN1T__unstructuredName_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__unstructuredName_Type
  (ASN1CTXT* pctxt, ASN1T__unstructuredName_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__unstructuredName_Type (ASN1CTXT *pctxt, ASN1T__unstructuredName_Type* pSrcValue, ASN1T__unstructuredName_Type* pDstValue);

EXTERN void asn1Free__unstructuredName_Type (ASN1CTXT *pctxt, ASN1T__unstructuredName_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _postalCode_Type                                          */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T__postalCode_Type_utf8String   1
#define T__postalCode_Type_printableString 2
#define T__postalCode_Type_teletexString 3
#define T__postalCode_Type_universalString 4
#define T__postalCode_Type_bmpString    5

class EXTERN ASN1C__postalCode_Type;

typedef struct EXTERN ASN1T__postalCode_Type : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1PrintableString printableString;
      /* t = 3 */
      ASN1T61String teletexString;
      /* t = 4 */
      ASN1UniversalString universalString;
      /* t = 5 */
      ASN1BMPString bmpString;
   } u;
   ASN1T__postalCode_Type () {}
   ASN1T__postalCode_Type (ASN1C__postalCode_Type& srcData);
   ~ASN1T__postalCode_Type ();
} ASN1T__postalCode_Type;

class EXTERN ASN1C__postalCode_Type :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__postalCode_Type& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, printableString, teletexString,
         universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C__postalCode_Type (ASN1T__postalCode_Type& data);
   ASN1C__postalCode_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__postalCode_Type& data);
   ASN1C__postalCode_Type (ASN1C__postalCode_Type& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__postalCode_Type& getCopy (ASN1T__postalCode_Type* pDstData = 0);
   ASN1T__postalCode_Type* newCopy ();

   inline ASN1C__postalCode_Type& operator= (ASN1C__postalCode_Type& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__postalCode_Type (ASN1CTXT* pctxt,
   ASN1T__postalCode_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__postalCode_Type (ASN1CTXT* pctxt,
   ASN1T__postalCode_Type *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__postalCode_Type
  (ASN1CTXT* pctxt, ASN1T__postalCode_Type* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__postalCode_Type (ASN1CTXT *pctxt, ASN1T__postalCode_Type* pSrcValue, ASN1T__postalCode_Type* pDstValue);

EXTERN void asn1Free__postalCode_Type (ASN1CTXT *pctxt, ASN1T__postalCode_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  PostalAddress_element                                     */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PostalAddress_element_utf8String 1
#define T_PostalAddress_element_printableString 2
#define T_PostalAddress_element_teletexString 3
#define T_PostalAddress_element_universalString 4
#define T_PostalAddress_element_bmpString 5

class EXTERN ASN1C_PostalAddress_element;

typedef struct EXTERN ASN1T_PostalAddress_element : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1PrintableString printableString;
      /* t = 3 */
      ASN1T61String teletexString;
      /* t = 4 */
      ASN1UniversalString universalString;
      /* t = 5 */
      ASN1BMPString bmpString;
   } u;
   ASN1T_PostalAddress_element () {}
   ASN1T_PostalAddress_element (ASN1C_PostalAddress_element& srcData);
   ~ASN1T_PostalAddress_element ();
} ASN1T_PostalAddress_element;

class EXTERN ASN1C_PostalAddress_element :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PostalAddress_element& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, printableString, teletexString,
         universalString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_PostalAddress_element (ASN1T_PostalAddress_element& data);
   ASN1C_PostalAddress_element (
      ASN1MessageBufferIF& msgBuf, ASN1T_PostalAddress_element& data);
   ASN1C_PostalAddress_element (ASN1C_PostalAddress_element& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PostalAddress_element& getCopy (ASN1T_PostalAddress_element* pDstData = 0);
   ASN1T_PostalAddress_element* newCopy ();

   inline ASN1C_PostalAddress_element& operator= (ASN1C_PostalAddress_element& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PostalAddress_element (ASN1CTXT* pctxt,
   ASN1T_PostalAddress_element *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PostalAddress_element (ASN1CTXT* pctxt,
   ASN1T_PostalAddress_element *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PostalAddress_element
  (ASN1CTXT* pctxt, ASN1T_PostalAddress_element* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PostalAddress_element (ASN1CTXT *pctxt, ASN1T_PostalAddress_element* pSrcValue, ASN1T_PostalAddress_element* pDstValue);

EXTERN void asn1Free_PostalAddress_element (ASN1CTXT *pctxt, ASN1T_PostalAddress_element* pvalue);

/**************************************************************/
/*                                                            */
/*  PostalAddress                                             */
/*                                                            */
/**************************************************************/

/* List of ASN1T_PostalAddress_element */
typedef struct EXTERN ASN1T_PostalAddress : public ASN1TPDUSeqOfList {
   ~ASN1T_PostalAddress();
} ASN1T_PostalAddress;

class EXTERN ASN1C_PostalAddress :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PostalAddress& msgData;
   ASN1T_PostalAddress_element *mpElement;
   class ASN1C_PostalAddress_element* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_PostalAddress (ASN1T_PostalAddress& data);
   ASN1C_PostalAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_PostalAddress& data);
   ASN1C_PostalAddress (ASN1C_PostalAddress& original);

   ~ASN1C_PostalAddress();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PostalAddress& getCopy (ASN1T_PostalAddress* pDstData = 0);
   ASN1T_PostalAddress* newCopy ();

   ASN1C_PostalAddress& operator= (ASN1C_PostalAddress& srcData);
   void Append (ASN1T_PostalAddress_element * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PostalAddress (ASN1CTXT* pctxt,
   ASN1T_PostalAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PostalAddress (ASN1CTXT* pctxt,
   ASN1T_PostalAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PostalAddress
  (ASN1CTXT* pctxt, ASN1T_PostalAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PostalAddress (ASN1CTXT *pctxt, ASN1T_PostalAddress* pSrcValue, ASN1T_PostalAddress* pDstValue);

EXTERN void asn1Free_PostalAddress (ASN1CTXT *pctxt, ASN1T_PostalAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  AttributeTypeAndValue                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_AttributeTypeAndValue;

typedef struct EXTERN ASN1T_AttributeTypeAndValue : public ASN1TPDU {
   ASN1TObjId type;
   Asn1TObject value;
   ASN1T_AttributeTypeAndValue ();
   ASN1T_AttributeTypeAndValue (ASN1C_AttributeTypeAndValue& srcData);
   ~ASN1T_AttributeTypeAndValue ();
} ASN1T_AttributeTypeAndValue;

class EXTERN ASN1C_AttributeTypeAndValue :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AttributeTypeAndValue& msgData;
   struct ElementID {
      enum {
         _unknown, type, value
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1CXerOpenType* mpValueC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_AttributeTypeAndValue (ASN1T_AttributeTypeAndValue& data);
   ASN1C_AttributeTypeAndValue (
      ASN1MessageBufferIF& msgBuf, ASN1T_AttributeTypeAndValue& data);
   ASN1C_AttributeTypeAndValue (ASN1C_AttributeTypeAndValue& original);

   ~ASN1C_AttributeTypeAndValue();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_AttributeTypeAndValue& getCopy (ASN1T_AttributeTypeAndValue* pDstData = 0);
   ASN1T_AttributeTypeAndValue* newCopy ();

   inline ASN1C_AttributeTypeAndValue& operator= (ASN1C_AttributeTypeAndValue& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_AttributeTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_AttributeTypeAndValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AttributeTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_AttributeTypeAndValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AttributeTypeAndValue
  (ASN1CTXT* pctxt, ASN1T_AttributeTypeAndValue* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN int asn1XETC_AttributeTypeAndValue (ASN1CTXT* pctxt,
    ASN1T_AttributeTypeAndValue *pvalue);

EXTERN int asn1XDTC_AttributeTypeAndValue (ASN1CtxtPtr& pctxt,
    ASN1T_AttributeTypeAndValue *pvalue);

EXTERN int asn1ETC_AttributeTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_AttributeTypeAndValue *pvalue);

EXTERN int asn1DTC_AttributeTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_AttributeTypeAndValue *pvalue);

EXTERN void asn1Copy_AttributeTypeAndValue (ASN1CTXT *pctxt, ASN1T_AttributeTypeAndValue* pSrcValue, ASN1T_AttributeTypeAndValue* pDstValue);

EXTERN void asn1Free_AttributeTypeAndValue (ASN1CTXT *pctxt, ASN1T_AttributeTypeAndValue* pvalue);

/**************************************************************/
/*                                                            */
/*  RelativeDistinguishedName                                 */
/*                                                            */
/**************************************************************/

/* List of ASN1T_AttributeTypeAndValue */
typedef struct EXTERN ASN1T_RelativeDistinguishedName : public ASN1TPDUSeqOfList {
   ~ASN1T_RelativeDistinguishedName();
} ASN1T_RelativeDistinguishedName;

class EXTERN ASN1C_RelativeDistinguishedName :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_RelativeDistinguishedName& msgData;
   ASN1T_AttributeTypeAndValue *mpElement;
   class ASN1C_AttributeTypeAndValue* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_RelativeDistinguishedName (ASN1T_RelativeDistinguishedName& data);
   ASN1C_RelativeDistinguishedName (
      ASN1MessageBufferIF& msgBuf, ASN1T_RelativeDistinguishedName& data);
   ASN1C_RelativeDistinguishedName (ASN1C_RelativeDistinguishedName& original);

   ~ASN1C_RelativeDistinguishedName();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_RelativeDistinguishedName& getCopy (ASN1T_RelativeDistinguishedName* pDstData = 0);
   ASN1T_RelativeDistinguishedName* newCopy ();

   ASN1C_RelativeDistinguishedName& operator= (ASN1C_RelativeDistinguishedName& srcData);
   void Append (ASN1T_AttributeTypeAndValue * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_RelativeDistinguishedName (ASN1CTXT* pctxt,
   ASN1T_RelativeDistinguishedName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RelativeDistinguishedName (ASN1CTXT* pctxt,
   ASN1T_RelativeDistinguishedName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RelativeDistinguishedName
  (ASN1CTXT* pctxt, ASN1T_RelativeDistinguishedName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RelativeDistinguishedName (ASN1CTXT *pctxt, ASN1T_RelativeDistinguishedName* pSrcValue, ASN1T_RelativeDistinguishedName* pDstValue);

EXTERN void asn1Free_RelativeDistinguishedName (ASN1CTXT *pctxt, ASN1T_RelativeDistinguishedName* pvalue);

/**************************************************************/
/*                                                            */
/*  RDNSequence                                               */
/*                                                            */
/**************************************************************/

/* List of ASN1T_RelativeDistinguishedName */
typedef struct EXTERN ASN1T_RDNSequence : public ASN1TPDUSeqOfList {
   ~ASN1T_RDNSequence();
} ASN1T_RDNSequence;

class EXTERN ASN1C_RDNSequence :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_RDNSequence& msgData;
   ASN1T_RelativeDistinguishedName *mpElement;
   class ASN1C_RelativeDistinguishedName* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_RDNSequence (ASN1T_RDNSequence& data);
   ASN1C_RDNSequence (
      ASN1MessageBufferIF& msgBuf, ASN1T_RDNSequence& data);
   ASN1C_RDNSequence (ASN1C_RDNSequence& original);

   ~ASN1C_RDNSequence();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_RDNSequence& getCopy (ASN1T_RDNSequence* pDstData = 0);
   ASN1T_RDNSequence* newCopy ();

   ASN1C_RDNSequence& operator= (ASN1C_RDNSequence& srcData);
   void Append (ASN1T_RelativeDistinguishedName * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_RDNSequence (ASN1CTXT* pctxt,
   ASN1T_RDNSequence *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RDNSequence (ASN1CTXT* pctxt,
   ASN1T_RDNSequence *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RDNSequence
  (ASN1CTXT* pctxt, ASN1T_RDNSequence* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RDNSequence (ASN1CTXT *pctxt, ASN1T_RDNSequence* pSrcValue, ASN1T_RDNSequence* pDstValue);

EXTERN void asn1Free_RDNSequence (ASN1CTXT *pctxt, ASN1T_RDNSequence* pvalue);

/**************************************************************/
/*                                                            */
/*  DistinguishedName                                         */
/*                                                            */
/**************************************************************/

typedef ASN1T_RDNSequence ASN1T_DistinguishedName;

class EXTERN ASN1C_DistinguishedName :
   public ASN1C_RDNSequence
{
protected:
public:
   ASN1C_DistinguishedName (ASN1T_DistinguishedName& data);
   ASN1C_DistinguishedName (
      ASN1MessageBufferIF& msgBuf, ASN1T_DistinguishedName& data);
   ASN1C_DistinguishedName (ASN1C_DistinguishedName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_DistinguishedName& getCopy (ASN1T_DistinguishedName* pDstData = 0);
   ASN1T_DistinguishedName* newCopy ();

   inline ASN1C_DistinguishedName& operator= (ASN1C_DistinguishedName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_DistinguishedName (ASN1CTXT* pctxt,
   ASN1T_DistinguishedName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DistinguishedName (ASN1CTXT* pctxt,
   ASN1T_DistinguishedName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DistinguishedName
  (ASN1CTXT* pctxt, ASN1T_DistinguishedName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DistinguishedName (ASN1CTXT *pctxt, ASN1T_DistinguishedName* pSrcValue, ASN1T_DistinguishedName* pDstValue);

EXTERN void asn1Free_DistinguishedName (ASN1CTXT *pctxt, ASN1T_DistinguishedName* pvalue);

/**************************************************************/
/*                                                            */
/*  CommonName                                                */
/*                                                            */
/**************************************************************/

typedef ASN1PrintableString ASN1T_CommonName;

class EXTERN ASN1C_CommonName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CommonName& msgData;
public:
   ASN1C_CommonName (ASN1T_CommonName& data);
   ASN1C_CommonName (
      ASN1MessageBufferIF& msgBuf, ASN1T_CommonName& data);
   ASN1C_CommonName (ASN1C_CommonName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CommonName& getCopy (ASN1T_CommonName* pDstData = 0);
   ASN1T_CommonName* newCopy ();

   inline ASN1C_CommonName& operator= (ASN1C_CommonName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CommonName (ASN1CTXT* pctxt,
   ASN1T_CommonName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CommonName (ASN1CTXT* pctxt,
   ASN1T_CommonName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CommonName
  (ASN1CTXT* pctxt, ASN1T_CommonName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CommonName (ASN1CTXT *pctxt, ASN1T_CommonName* pSrcValue, ASN1T_CommonName* pDstValue);

EXTERN void asn1Free_CommonName (ASN1CTXT *pctxt, ASN1T_CommonName* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexCommonName                                         */
/*                                                            */
/**************************************************************/

typedef ASN1T61String ASN1T_TeletexCommonName;

class EXTERN ASN1C_TeletexCommonName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexCommonName& msgData;
public:
   ASN1C_TeletexCommonName (ASN1T_TeletexCommonName& data);
   ASN1C_TeletexCommonName (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexCommonName& data);
   ASN1C_TeletexCommonName (ASN1C_TeletexCommonName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexCommonName& getCopy (ASN1T_TeletexCommonName* pDstData = 0);
   ASN1T_TeletexCommonName* newCopy ();

   inline ASN1C_TeletexCommonName& operator= (ASN1C_TeletexCommonName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_TeletexCommonName (ASN1CTXT* pctxt,
   ASN1T_TeletexCommonName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexCommonName (ASN1CTXT* pctxt,
   ASN1T_TeletexCommonName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexCommonName
  (ASN1CTXT* pctxt, ASN1T_TeletexCommonName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexCommonName (ASN1CTXT *pctxt, ASN1T_TeletexCommonName* pSrcValue, ASN1T_TeletexCommonName* pDstValue);

EXTERN void asn1Free_TeletexCommonName (ASN1CTXT *pctxt, ASN1T_TeletexCommonName* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexOrganizationName                                   */
/*                                                            */
/**************************************************************/

typedef ASN1T61String ASN1T_TeletexOrganizationName;

class EXTERN ASN1C_TeletexOrganizationName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexOrganizationName& msgData;
public:
   ASN1C_TeletexOrganizationName (ASN1T_TeletexOrganizationName& data);
   ASN1C_TeletexOrganizationName (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexOrganizationName& data);
   ASN1C_TeletexOrganizationName (ASN1C_TeletexOrganizationName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexOrganizationName& getCopy (ASN1T_TeletexOrganizationName* pDstData = 0);
   ASN1T_TeletexOrganizationName* newCopy ();

   inline ASN1C_TeletexOrganizationName& operator= (ASN1C_TeletexOrganizationName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_TeletexOrganizationName (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexOrganizationName (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexOrganizationName
  (ASN1CTXT* pctxt, ASN1T_TeletexOrganizationName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexOrganizationName (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationName* pSrcValue, ASN1T_TeletexOrganizationName* pDstValue);

EXTERN void asn1Free_TeletexOrganizationName (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationName* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexOrganizationalUnitName                             */
/*                                                            */
/**************************************************************/

typedef ASN1T61String ASN1T_TeletexOrganizationalUnitName;

class EXTERN ASN1C_TeletexOrganizationalUnitName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexOrganizationalUnitName& msgData;
public:
   ASN1C_TeletexOrganizationalUnitName (ASN1T_TeletexOrganizationalUnitName& data);
   ASN1C_TeletexOrganizationalUnitName (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexOrganizationalUnitName& data);
   ASN1C_TeletexOrganizationalUnitName (ASN1C_TeletexOrganizationalUnitName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexOrganizationalUnitName& getCopy (ASN1T_TeletexOrganizationalUnitName* pDstData = 0);
   ASN1T_TeletexOrganizationalUnitName* newCopy ();

   inline ASN1C_TeletexOrganizationalUnitName& operator= (ASN1C_TeletexOrganizationalUnitName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_TeletexOrganizationalUnitName (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationalUnitName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexOrganizationalUnitName (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationalUnitName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexOrganizationalUnitName
  (ASN1CTXT* pctxt, ASN1T_TeletexOrganizationalUnitName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexOrganizationalUnitName (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationalUnitName* pSrcValue, ASN1T_TeletexOrganizationalUnitName* pDstValue);

EXTERN void asn1Free_TeletexOrganizationalUnitName (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationalUnitName* pvalue);

/**************************************************************/
/*                                                            */
/*  PDSName                                                   */
/*                                                            */
/**************************************************************/

typedef ASN1PrintableString ASN1T_PDSName;

class EXTERN ASN1C_PDSName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PDSName& msgData;
public:
   ASN1C_PDSName (ASN1T_PDSName& data);
   ASN1C_PDSName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PDSName& data);
   ASN1C_PDSName (ASN1C_PDSName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PDSName& getCopy (ASN1T_PDSName* pDstData = 0);
   ASN1T_PDSName* newCopy ();

   inline ASN1C_PDSName& operator= (ASN1C_PDSName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PDSName (ASN1CTXT* pctxt,
   ASN1T_PDSName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PDSName (ASN1CTXT* pctxt,
   ASN1T_PDSName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PDSName
  (ASN1CTXT* pctxt, ASN1T_PDSName value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PDSName (ASN1CTXT *pctxt, ASN1T_PDSName* pSrcValue, ASN1T_PDSName* pDstValue);

EXTERN void asn1Free_PDSName (ASN1CTXT *pctxt, ASN1T_PDSName* pvalue);

/**************************************************************/
/*                                                            */
/*  PDSParameter                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PDSParameter;

typedef struct EXTERN ASN1T_PDSParameter : public ASN1TPDU {
   struct {
      unsigned printable_stringPresent : 1;
      unsigned teletex_stringPresent : 1;
   } m;
   ASN1PrintableString printable_string;
   ASN1T61String teletex_string;
   ASN1T_PDSParameter ();
   ASN1T_PDSParameter (ASN1C_PDSParameter& srcData);
   ~ASN1T_PDSParameter ();
} ASN1T_PDSParameter;

class EXTERN ASN1C_PDSParameter :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PDSParameter& msgData;
   struct ElementID {
      enum {
         _unknown, printable_string, teletex_string
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PDSParameter (ASN1T_PDSParameter& data);
   ASN1C_PDSParameter (
      ASN1MessageBufferIF& msgBuf, ASN1T_PDSParameter& data);
   ASN1C_PDSParameter (ASN1C_PDSParameter& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PDSParameter& getCopy (ASN1T_PDSParameter* pDstData = 0);
   ASN1T_PDSParameter* newCopy ();

   inline ASN1C_PDSParameter& operator= (ASN1C_PDSParameter& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PDSParameter (ASN1CTXT* pctxt,
   ASN1T_PDSParameter *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PDSParameter (ASN1CTXT* pctxt,
   ASN1T_PDSParameter *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PDSParameter
  (ASN1CTXT* pctxt, ASN1T_PDSParameter* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PDSParameter (ASN1CTXT *pctxt, ASN1T_PDSParameter* pSrcValue, ASN1T_PDSParameter* pDstValue);

EXTERN void asn1Free_PDSParameter (ASN1CTXT *pctxt, ASN1T_PDSParameter* pvalue);

/**************************************************************/
/*                                                            */
/*  PhysicalDeliveryOfficeName                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PhysicalDeliveryOfficeName;

typedef ASN1T_PDSParameter ASN1T_PhysicalDeliveryOfficeName;

class EXTERN ASN1C_PhysicalDeliveryOfficeName :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PhysicalDeliveryOfficeName (ASN1T_PhysicalDeliveryOfficeName& data);
   ASN1C_PhysicalDeliveryOfficeName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PhysicalDeliveryOfficeName& data);
   ASN1C_PhysicalDeliveryOfficeName (ASN1C_PhysicalDeliveryOfficeName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PhysicalDeliveryOfficeName& getCopy (ASN1T_PhysicalDeliveryOfficeName* pDstData = 0);
   ASN1T_PhysicalDeliveryOfficeName* newCopy ();

   inline ASN1C_PhysicalDeliveryOfficeName& operator= (ASN1C_PhysicalDeliveryOfficeName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PhysicalDeliveryOfficeName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOfficeName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PhysicalDeliveryOfficeName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOfficeName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PhysicalDeliveryOfficeName
  (ASN1CTXT* pctxt, ASN1T_PhysicalDeliveryOfficeName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PhysicalDeliveryOfficeName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOfficeName* pSrcValue, ASN1T_PhysicalDeliveryOfficeName* pDstValue);

EXTERN void asn1Free_PhysicalDeliveryOfficeName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOfficeName* pvalue);

/**************************************************************/
/*                                                            */
/*  PhysicalDeliveryOfficeNumber                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PhysicalDeliveryOfficeNumber;

typedef ASN1T_PDSParameter ASN1T_PhysicalDeliveryOfficeNumber;

class EXTERN ASN1C_PhysicalDeliveryOfficeNumber :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PhysicalDeliveryOfficeNumber (ASN1T_PhysicalDeliveryOfficeNumber& data);
   ASN1C_PhysicalDeliveryOfficeNumber (
      ASN1MessageBufferIF& msgBuf, ASN1T_PhysicalDeliveryOfficeNumber& data);
   ASN1C_PhysicalDeliveryOfficeNumber (ASN1C_PhysicalDeliveryOfficeNumber& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PhysicalDeliveryOfficeNumber& getCopy (ASN1T_PhysicalDeliveryOfficeNumber* pDstData = 0);
   ASN1T_PhysicalDeliveryOfficeNumber* newCopy ();

   inline ASN1C_PhysicalDeliveryOfficeNumber& operator= (ASN1C_PhysicalDeliveryOfficeNumber& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PhysicalDeliveryOfficeNumber (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOfficeNumber *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PhysicalDeliveryOfficeNumber (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOfficeNumber *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PhysicalDeliveryOfficeNumber
  (ASN1CTXT* pctxt, ASN1T_PhysicalDeliveryOfficeNumber* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PhysicalDeliveryOfficeNumber (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOfficeNumber* pSrcValue, ASN1T_PhysicalDeliveryOfficeNumber* pDstValue);

EXTERN void asn1Free_PhysicalDeliveryOfficeNumber (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOfficeNumber* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtensionORAddressComponents                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ExtensionORAddressComponents;

typedef ASN1T_PDSParameter ASN1T_ExtensionORAddressComponents;

class EXTERN ASN1C_ExtensionORAddressComponents :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_ExtensionORAddressComponents (ASN1T_ExtensionORAddressComponents& data);
   ASN1C_ExtensionORAddressComponents (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtensionORAddressComponents& data);
   ASN1C_ExtensionORAddressComponents (ASN1C_ExtensionORAddressComponents& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtensionORAddressComponents& getCopy (ASN1T_ExtensionORAddressComponents* pDstData = 0);
   ASN1T_ExtensionORAddressComponents* newCopy ();

   inline ASN1C_ExtensionORAddressComponents& operator= (ASN1C_ExtensionORAddressComponents& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_ExtensionORAddressComponents (ASN1CTXT* pctxt,
   ASN1T_ExtensionORAddressComponents *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtensionORAddressComponents (ASN1CTXT* pctxt,
   ASN1T_ExtensionORAddressComponents *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtensionORAddressComponents
  (ASN1CTXT* pctxt, ASN1T_ExtensionORAddressComponents* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtensionORAddressComponents (ASN1CTXT *pctxt, ASN1T_ExtensionORAddressComponents* pSrcValue, ASN1T_ExtensionORAddressComponents* pDstValue);

EXTERN void asn1Free_ExtensionORAddressComponents (ASN1CTXT *pctxt, ASN1T_ExtensionORAddressComponents* pvalue);

/**************************************************************/
/*                                                            */
/*  PhysicalDeliveryPersonalName                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PhysicalDeliveryPersonalName;

typedef ASN1T_PDSParameter ASN1T_PhysicalDeliveryPersonalName;

class EXTERN ASN1C_PhysicalDeliveryPersonalName :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PhysicalDeliveryPersonalName (ASN1T_PhysicalDeliveryPersonalName& data);
   ASN1C_PhysicalDeliveryPersonalName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PhysicalDeliveryPersonalName& data);
   ASN1C_PhysicalDeliveryPersonalName (ASN1C_PhysicalDeliveryPersonalName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PhysicalDeliveryPersonalName& getCopy (ASN1T_PhysicalDeliveryPersonalName* pDstData = 0);
   ASN1T_PhysicalDeliveryPersonalName* newCopy ();

   inline ASN1C_PhysicalDeliveryPersonalName& operator= (ASN1C_PhysicalDeliveryPersonalName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PhysicalDeliveryPersonalName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryPersonalName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PhysicalDeliveryPersonalName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryPersonalName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PhysicalDeliveryPersonalName
  (ASN1CTXT* pctxt, ASN1T_PhysicalDeliveryPersonalName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PhysicalDeliveryPersonalName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryPersonalName* pSrcValue, ASN1T_PhysicalDeliveryPersonalName* pDstValue);

EXTERN void asn1Free_PhysicalDeliveryPersonalName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryPersonalName* pvalue);

/**************************************************************/
/*                                                            */
/*  PhysicalDeliveryOrganizationName                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PhysicalDeliveryOrganizationName;

typedef ASN1T_PDSParameter ASN1T_PhysicalDeliveryOrganizationName;

class EXTERN ASN1C_PhysicalDeliveryOrganizationName :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PhysicalDeliveryOrganizationName (ASN1T_PhysicalDeliveryOrganizationName& data);
   ASN1C_PhysicalDeliveryOrganizationName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PhysicalDeliveryOrganizationName& data);
   ASN1C_PhysicalDeliveryOrganizationName (ASN1C_PhysicalDeliveryOrganizationName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PhysicalDeliveryOrganizationName& getCopy (ASN1T_PhysicalDeliveryOrganizationName* pDstData = 0);
   ASN1T_PhysicalDeliveryOrganizationName* newCopy ();

   inline ASN1C_PhysicalDeliveryOrganizationName& operator= (ASN1C_PhysicalDeliveryOrganizationName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PhysicalDeliveryOrganizationName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOrganizationName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PhysicalDeliveryOrganizationName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryOrganizationName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PhysicalDeliveryOrganizationName
  (ASN1CTXT* pctxt, ASN1T_PhysicalDeliveryOrganizationName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PhysicalDeliveryOrganizationName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOrganizationName* pSrcValue, ASN1T_PhysicalDeliveryOrganizationName* pDstValue);

EXTERN void asn1Free_PhysicalDeliveryOrganizationName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryOrganizationName* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtensionPhysicalDeliveryAddressComponents                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ExtensionPhysicalDeliveryAddressComponents;

typedef ASN1T_PDSParameter ASN1T_ExtensionPhysicalDeliveryAddressComponents;

class EXTERN ASN1C_ExtensionPhysicalDeliveryAddressComponents :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_ExtensionPhysicalDeliveryAddressComponents (ASN1T_ExtensionPhysicalDeliveryAddressComponents& data);
   ASN1C_ExtensionPhysicalDeliveryAddressComponents (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtensionPhysicalDeliveryAddressComponents& data);
   ASN1C_ExtensionPhysicalDeliveryAddressComponents (ASN1C_ExtensionPhysicalDeliveryAddressComponents& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtensionPhysicalDeliveryAddressComponents& getCopy (ASN1T_ExtensionPhysicalDeliveryAddressComponents* pDstData = 0);
   ASN1T_ExtensionPhysicalDeliveryAddressComponents* newCopy ();

   inline ASN1C_ExtensionPhysicalDeliveryAddressComponents& operator= (ASN1C_ExtensionPhysicalDeliveryAddressComponents& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_ExtensionPhysicalDeliveryAddressComponents (ASN1CTXT* pctxt,
   ASN1T_ExtensionPhysicalDeliveryAddressComponents *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtensionPhysicalDeliveryAddressComponents (ASN1CTXT* pctxt,
   ASN1T_ExtensionPhysicalDeliveryAddressComponents *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtensionPhysicalDeliveryAddressComponents
  (ASN1CTXT* pctxt, ASN1T_ExtensionPhysicalDeliveryAddressComponents* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtensionPhysicalDeliveryAddressComponents (ASN1CTXT *pctxt, ASN1T_ExtensionPhysicalDeliveryAddressComponents* pSrcValue, ASN1T_ExtensionPhysicalDeliveryAddressComponents* pDstValue);

EXTERN void asn1Free_ExtensionPhysicalDeliveryAddressComponents (ASN1CTXT *pctxt, ASN1T_ExtensionPhysicalDeliveryAddressComponents* pvalue);

/**************************************************************/
/*                                                            */
/*  StreetAddress                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_StreetAddress;

typedef ASN1T_PDSParameter ASN1T_StreetAddress;

class EXTERN ASN1C_StreetAddress :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_StreetAddress (ASN1T_StreetAddress& data);
   ASN1C_StreetAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_StreetAddress& data);
   ASN1C_StreetAddress (ASN1C_StreetAddress& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_StreetAddress& getCopy (ASN1T_StreetAddress* pDstData = 0);
   ASN1T_StreetAddress* newCopy ();

   inline ASN1C_StreetAddress& operator= (ASN1C_StreetAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_StreetAddress (ASN1CTXT* pctxt,
   ASN1T_StreetAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_StreetAddress (ASN1CTXT* pctxt,
   ASN1T_StreetAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_StreetAddress
  (ASN1CTXT* pctxt, ASN1T_StreetAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_StreetAddress (ASN1CTXT *pctxt, ASN1T_StreetAddress* pSrcValue, ASN1T_StreetAddress* pDstValue);

EXTERN void asn1Free_StreetAddress (ASN1CTXT *pctxt, ASN1T_StreetAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  PostOfficeBoxAddress                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PostOfficeBoxAddress;

typedef ASN1T_PDSParameter ASN1T_PostOfficeBoxAddress;

class EXTERN ASN1C_PostOfficeBoxAddress :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PostOfficeBoxAddress (ASN1T_PostOfficeBoxAddress& data);
   ASN1C_PostOfficeBoxAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_PostOfficeBoxAddress& data);
   ASN1C_PostOfficeBoxAddress (ASN1C_PostOfficeBoxAddress& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PostOfficeBoxAddress& getCopy (ASN1T_PostOfficeBoxAddress* pDstData = 0);
   ASN1T_PostOfficeBoxAddress* newCopy ();

   inline ASN1C_PostOfficeBoxAddress& operator= (ASN1C_PostOfficeBoxAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PostOfficeBoxAddress (ASN1CTXT* pctxt,
   ASN1T_PostOfficeBoxAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PostOfficeBoxAddress (ASN1CTXT* pctxt,
   ASN1T_PostOfficeBoxAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PostOfficeBoxAddress
  (ASN1CTXT* pctxt, ASN1T_PostOfficeBoxAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PostOfficeBoxAddress (ASN1CTXT *pctxt, ASN1T_PostOfficeBoxAddress* pSrcValue, ASN1T_PostOfficeBoxAddress* pDstValue);

EXTERN void asn1Free_PostOfficeBoxAddress (ASN1CTXT *pctxt, ASN1T_PostOfficeBoxAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  PosteRestanteAddress                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PosteRestanteAddress;

typedef ASN1T_PDSParameter ASN1T_PosteRestanteAddress;

class EXTERN ASN1C_PosteRestanteAddress :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_PosteRestanteAddress (ASN1T_PosteRestanteAddress& data);
   ASN1C_PosteRestanteAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_PosteRestanteAddress& data);
   ASN1C_PosteRestanteAddress (ASN1C_PosteRestanteAddress& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PosteRestanteAddress& getCopy (ASN1T_PosteRestanteAddress* pDstData = 0);
   ASN1T_PosteRestanteAddress* newCopy ();

   inline ASN1C_PosteRestanteAddress& operator= (ASN1C_PosteRestanteAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PosteRestanteAddress (ASN1CTXT* pctxt,
   ASN1T_PosteRestanteAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PosteRestanteAddress (ASN1CTXT* pctxt,
   ASN1T_PosteRestanteAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PosteRestanteAddress
  (ASN1CTXT* pctxt, ASN1T_PosteRestanteAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PosteRestanteAddress (ASN1CTXT *pctxt, ASN1T_PosteRestanteAddress* pSrcValue, ASN1T_PosteRestanteAddress* pDstValue);

EXTERN void asn1Free_PosteRestanteAddress (ASN1CTXT *pctxt, ASN1T_PosteRestanteAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  UniquePostalName                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_UniquePostalName;

typedef ASN1T_PDSParameter ASN1T_UniquePostalName;

class EXTERN ASN1C_UniquePostalName :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_UniquePostalName (ASN1T_UniquePostalName& data);
   ASN1C_UniquePostalName (
      ASN1MessageBufferIF& msgBuf, ASN1T_UniquePostalName& data);
   ASN1C_UniquePostalName (ASN1C_UniquePostalName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_UniquePostalName& getCopy (ASN1T_UniquePostalName* pDstData = 0);
   ASN1T_UniquePostalName* newCopy ();

   inline ASN1C_UniquePostalName& operator= (ASN1C_UniquePostalName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_UniquePostalName (ASN1CTXT* pctxt,
   ASN1T_UniquePostalName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_UniquePostalName (ASN1CTXT* pctxt,
   ASN1T_UniquePostalName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_UniquePostalName
  (ASN1CTXT* pctxt, ASN1T_UniquePostalName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_UniquePostalName (ASN1CTXT *pctxt, ASN1T_UniquePostalName* pSrcValue, ASN1T_UniquePostalName* pDstValue);

EXTERN void asn1Free_UniquePostalName (ASN1CTXT *pctxt, ASN1T_UniquePostalName* pvalue);

/**************************************************************/
/*                                                            */
/*  LocalPostalAttributes                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_LocalPostalAttributes;

typedef ASN1T_PDSParameter ASN1T_LocalPostalAttributes;

class EXTERN ASN1C_LocalPostalAttributes :
   public ASN1C_PDSParameter
{
protected:
public:
   ASN1C_LocalPostalAttributes (ASN1T_LocalPostalAttributes& data);
   ASN1C_LocalPostalAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_LocalPostalAttributes& data);
   ASN1C_LocalPostalAttributes (ASN1C_LocalPostalAttributes& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_LocalPostalAttributes& getCopy (ASN1T_LocalPostalAttributes* pDstData = 0);
   ASN1T_LocalPostalAttributes* newCopy ();

   inline ASN1C_LocalPostalAttributes& operator= (ASN1C_LocalPostalAttributes& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_LocalPostalAttributes (ASN1CTXT* pctxt,
   ASN1T_LocalPostalAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_LocalPostalAttributes (ASN1CTXT* pctxt,
   ASN1T_LocalPostalAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_LocalPostalAttributes
  (ASN1CTXT* pctxt, ASN1T_LocalPostalAttributes* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_LocalPostalAttributes (ASN1CTXT *pctxt, ASN1T_LocalPostalAttributes* pSrcValue, ASN1T_LocalPostalAttributes* pDstValue);

EXTERN void asn1Free_LocalPostalAttributes (ASN1CTXT *pctxt, ASN1T_LocalPostalAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  TerminalType                                              */
/*                                                            */
/**************************************************************/

struct EXTERN TerminalType {
   enum Root {
      telex = 3,
      teletex = 4,
      g3_facsimile = 5,
      g4_facsimile = 6,
      ia5_terminal = 7,
      videotex = 8
   } ;
} ;

typedef ASN1USINT ASN1T_TerminalType;

class EXTERN ASN1C_TerminalType :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TerminalType& msgData;
public:
   ASN1C_TerminalType (ASN1T_TerminalType& data);
   ASN1C_TerminalType (
      ASN1MessageBufferIF& msgBuf, ASN1T_TerminalType& data);
   ASN1C_TerminalType (ASN1C_TerminalType& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TerminalType& getCopy (ASN1T_TerminalType* pDstData = 0);
   ASN1T_TerminalType* newCopy ();

   inline ASN1C_TerminalType& operator= (ASN1C_TerminalType& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
   static int parseNamedValue (ASN1CTXT* pctxt, ASN1USINT* value);
} ;

EXTERN int asn1E_TerminalType (ASN1CTXT* pctxt,
   ASN1T_TerminalType *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TerminalType (ASN1CTXT* pctxt,
   ASN1T_TerminalType *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TerminalType
  (ASN1CTXT* pctxt, ASN1T_TerminalType value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TerminalType (ASN1CTXT *pctxt, ASN1T_TerminalType* pSrcValue, ASN1T_TerminalType* pDstValue);

/**************************************************************/
/*                                                            */
/*  RsaModulus                                                */
/*                                                            */
/**************************************************************/

typedef ASN1ConstCharPtr ASN1T_RsaModulus;

class EXTERN ASN1C_RsaModulus :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_RsaModulus& msgData;
public:
   ASN1C_RsaModulus (ASN1T_RsaModulus& data);
   ASN1C_RsaModulus (
      ASN1MessageBufferIF& msgBuf, ASN1T_RsaModulus& data);
   ASN1C_RsaModulus (ASN1C_RsaModulus& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_RsaModulus& getCopy (ASN1T_RsaModulus* pDstData = 0);
   ASN1T_RsaModulus* newCopy ();

   inline ASN1C_RsaModulus& operator= (ASN1C_RsaModulus& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_RsaModulus (ASN1CTXT* pctxt,
   ASN1T_RsaModulus *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RsaModulus (ASN1CTXT* pctxt,
   ASN1T_RsaModulus *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RsaModulus
  (ASN1CTXT* pctxt, ASN1T_RsaModulus value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RsaModulus (ASN1CTXT *pctxt, ASN1T_RsaModulus* pSrcValue, ASN1T_RsaModulus* pDstValue);

/**************************************************************/
/*                                                            */
/*  CRTComponent                                              */
/*                                                            */
/**************************************************************/

typedef ASN1ConstCharPtr ASN1T_CRTComponent;

class EXTERN ASN1C_CRTComponent :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CRTComponent& msgData;
public:
   ASN1C_CRTComponent (ASN1T_CRTComponent& data);
   ASN1C_CRTComponent (
      ASN1MessageBufferIF& msgBuf, ASN1T_CRTComponent& data);
   ASN1C_CRTComponent (ASN1C_CRTComponent& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_CRTComponent& getCopy (ASN1T_CRTComponent* pDstData = 0);
   ASN1T_CRTComponent* newCopy ();

   inline ASN1C_CRTComponent& operator= (ASN1C_CRTComponent& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_CRTComponent (ASN1CTXT* pctxt,
   ASN1T_CRTComponent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRTComponent (ASN1CTXT* pctxt,
   ASN1T_CRTComponent *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CRTComponent
  (ASN1CTXT* pctxt, ASN1T_CRTComponent value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CRTComponent (ASN1CTXT *pctxt, ASN1T_CRTComponent* pSrcValue, ASN1T_CRTComponent* pDstValue);

/**************************************************************/
/*                                                            */
/*  PCI_Attribute                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PCI_Attribute;

typedef ASN1T_Attribute ASN1T_PCI_Attribute;

class EXTERN ASN1C_PCI_Attribute :
   public ASN1C_Attribute
{
protected:
public:
   ASN1C_PCI_Attribute (ASN1T_PCI_Attribute& data);
   ASN1C_PCI_Attribute (
      ASN1MessageBufferIF& msgBuf, ASN1T_PCI_Attribute& data);
   ASN1C_PCI_Attribute (ASN1C_PCI_Attribute& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PCI_Attribute& getCopy (ASN1T_PCI_Attribute* pDstData = 0);
   ASN1T_PCI_Attribute* newCopy ();

   inline ASN1C_PCI_Attribute& operator= (ASN1C_PCI_Attribute& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
} ;

EXTERN int asn1E_PCI_Attribute (ASN1CTXT* pctxt,
   ASN1T_PCI_Attribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PCI_Attribute (ASN1CTXT* pctxt,
   ASN1T_PCI_Attribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PCI_Attribute
  (ASN1CTXT* pctxt, ASN1T_PCI_Attribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PCI_Attribute (ASN1CTXT *pctxt, ASN1T_PCI_Attribute* pSrcValue, ASN1T_PCI_Attribute* pDstValue);

EXTERN void asn1Free_PCI_Attribute (ASN1CTXT *pctxt, ASN1T_PCI_Attribute* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexPersonalName                                       */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TeletexPersonalName;

typedef struct EXTERN ASN1T_TeletexPersonalName : public ASN1TPDU {
   struct {
      unsigned given_namePresent : 1;
      unsigned initialsPresent : 1;
      unsigned generation_qualifierPresent : 1;
   } m;
   ASN1T61String surname;
   ASN1T61String given_name;
   ASN1T61String initials;
   ASN1T61String generation_qualifier;
   ASN1T_TeletexPersonalName ();
   ASN1T_TeletexPersonalName (ASN1C_TeletexPersonalName& srcData);
   ~ASN1T_TeletexPersonalName ();
} ASN1T_TeletexPersonalName;

class EXTERN ASN1C_TeletexPersonalName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexPersonalName& msgData;
   struct ElementID {
      enum {
         _unknown, surname, given_name, initials, generation_qualifier
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_TeletexPersonalName (ASN1T_TeletexPersonalName& data);
   ASN1C_TeletexPersonalName (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexPersonalName& data);
   ASN1C_TeletexPersonalName (ASN1C_TeletexPersonalName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexPersonalName& getCopy (ASN1T_TeletexPersonalName* pDstData = 0);
   ASN1T_TeletexPersonalName* newCopy ();

   inline ASN1C_TeletexPersonalName& operator= (ASN1C_TeletexPersonalName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TeletexPersonalName (ASN1CTXT* pctxt,
   ASN1T_TeletexPersonalName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexPersonalName (ASN1CTXT* pctxt,
   ASN1T_TeletexPersonalName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexPersonalName
  (ASN1CTXT* pctxt, ASN1T_TeletexPersonalName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexPersonalName (ASN1CTXT *pctxt, ASN1T_TeletexPersonalName* pSrcValue, ASN1T_TeletexPersonalName* pDstValue);

EXTERN void asn1Free_TeletexPersonalName (ASN1CTXT *pctxt, ASN1T_TeletexPersonalName* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexOrganizationalUnitNames                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TeletexOrganizationalUnitNames;

typedef struct EXTERN ASN1T_TeletexOrganizationalUnitNames : public ASN1TPDU {
   ASN1UINT n;
   ASN1T_TeletexOrganizationalUnitName elem[4];
   ASN1T_TeletexOrganizationalUnitNames () : n (0) {}
   ASN1T_TeletexOrganizationalUnitNames (ASN1C_TeletexOrganizationalUnitNames& srcData);
   ~ASN1T_TeletexOrganizationalUnitNames ();
} ASN1T_TeletexOrganizationalUnitNames;

class EXTERN ASN1C_TeletexOrganizationalUnitNames :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexOrganizationalUnitNames& msgData;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_TeletexOrganizationalUnitNames (ASN1T_TeletexOrganizationalUnitNames& data);
   ASN1C_TeletexOrganizationalUnitNames (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexOrganizationalUnitNames& data);
   ASN1C_TeletexOrganizationalUnitNames (ASN1C_TeletexOrganizationalUnitNames& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexOrganizationalUnitNames& getCopy (ASN1T_TeletexOrganizationalUnitNames* pDstData = 0);
   ASN1T_TeletexOrganizationalUnitNames* newCopy ();

   ASN1C_TeletexOrganizationalUnitNames& operator= (ASN1C_TeletexOrganizationalUnitNames& srcData);

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TeletexOrganizationalUnitNames (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationalUnitNames *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexOrganizationalUnitNames (ASN1CTXT* pctxt,
   ASN1T_TeletexOrganizationalUnitNames *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexOrganizationalUnitNames
  (ASN1CTXT* pctxt, ASN1T_TeletexOrganizationalUnitNames* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexOrganizationalUnitNames (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationalUnitNames* pSrcValue, ASN1T_TeletexOrganizationalUnitNames* pDstValue);

EXTERN void asn1Free_TeletexOrganizationalUnitNames (ASN1CTXT *pctxt, ASN1T_TeletexOrganizationalUnitNames* pvalue);

/**************************************************************/
/*                                                            */
/*  PhysicalDeliveryCountryName                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PhysicalDeliveryCountryName_x121_dcc_code 1
#define T_PhysicalDeliveryCountryName_iso_3166_alpha2_code 2

class EXTERN ASN1C_PhysicalDeliveryCountryName;

typedef struct EXTERN ASN1T_PhysicalDeliveryCountryName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1NumericString x121_dcc_code;
      /* t = 2 */
      ASN1PrintableString iso_3166_alpha2_code;
   } u;
   ASN1T_PhysicalDeliveryCountryName () {}
   ASN1T_PhysicalDeliveryCountryName (ASN1C_PhysicalDeliveryCountryName& srcData);
   ~ASN1T_PhysicalDeliveryCountryName ();
} ASN1T_PhysicalDeliveryCountryName;

class EXTERN ASN1C_PhysicalDeliveryCountryName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PhysicalDeliveryCountryName& msgData;
   struct ElementID {
      enum {
         _unknown, x121_dcc_code, iso_3166_alpha2_code
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_PhysicalDeliveryCountryName (ASN1T_PhysicalDeliveryCountryName& data);
   ASN1C_PhysicalDeliveryCountryName (
      ASN1MessageBufferIF& msgBuf, ASN1T_PhysicalDeliveryCountryName& data);
   ASN1C_PhysicalDeliveryCountryName (ASN1C_PhysicalDeliveryCountryName& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PhysicalDeliveryCountryName& getCopy (ASN1T_PhysicalDeliveryCountryName* pDstData = 0);
   ASN1T_PhysicalDeliveryCountryName* newCopy ();

   inline ASN1C_PhysicalDeliveryCountryName& operator= (ASN1C_PhysicalDeliveryCountryName& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PhysicalDeliveryCountryName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryCountryName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PhysicalDeliveryCountryName (ASN1CTXT* pctxt,
   ASN1T_PhysicalDeliveryCountryName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PhysicalDeliveryCountryName
  (ASN1CTXT* pctxt, ASN1T_PhysicalDeliveryCountryName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PhysicalDeliveryCountryName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryCountryName* pSrcValue, ASN1T_PhysicalDeliveryCountryName* pDstValue);

EXTERN void asn1Free_PhysicalDeliveryCountryName (ASN1CTXT *pctxt, ASN1T_PhysicalDeliveryCountryName* pvalue);

/**************************************************************/
/*                                                            */
/*  PostalCode                                                */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PostalCode_numeric_code       1
#define T_PostalCode_printable_code     2

class EXTERN ASN1C_PostalCode;

typedef struct EXTERN ASN1T_PostalCode : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1NumericString numeric_code;
      /* t = 2 */
      ASN1PrintableString printable_code;
   } u;
   ASN1T_PostalCode () {}
   ASN1T_PostalCode (ASN1C_PostalCode& srcData);
   ~ASN1T_PostalCode ();
} ASN1T_PostalCode;

class EXTERN ASN1C_PostalCode :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PostalCode& msgData;
   struct ElementID {
      enum {
         _unknown, numeric_code, printable_code
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_PostalCode (ASN1T_PostalCode& data);
   ASN1C_PostalCode (
      ASN1MessageBufferIF& msgBuf, ASN1T_PostalCode& data);
   ASN1C_PostalCode (ASN1C_PostalCode& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PostalCode& getCopy (ASN1T_PostalCode* pDstData = 0);
   ASN1T_PostalCode* newCopy ();

   inline ASN1C_PostalCode& operator= (ASN1C_PostalCode& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PostalCode (ASN1CTXT* pctxt,
   ASN1T_PostalCode *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PostalCode (ASN1CTXT* pctxt,
   ASN1T_PostalCode *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PostalCode
  (ASN1CTXT* pctxt, ASN1T_PostalCode* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PostalCode (ASN1CTXT *pctxt, ASN1T_PostalCode* pSrcValue, ASN1T_PostalCode* pDstValue);

EXTERN void asn1Free_PostalCode (ASN1CTXT *pctxt, ASN1T_PostalCode* pvalue);

/**************************************************************/
/*                                                            */
/*  UnformattedPostalAddress_printable_address                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_UnformattedPostalAddress_printable_address;

typedef struct EXTERN ASN1T_UnformattedPostalAddress_printable_address : public ASN1TPDU {
   ASN1UINT n;
   ASN1PrintableString elem[6];
   ASN1T_UnformattedPostalAddress_printable_address () : n (0) {}
   ASN1T_UnformattedPostalAddress_printable_address (ASN1C_UnformattedPostalAddress_printable_address& srcData);
   ~ASN1T_UnformattedPostalAddress_printable_address ();
} ASN1T_UnformattedPostalAddress_printable_address;

class EXTERN ASN1C_UnformattedPostalAddress_printable_address :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_UnformattedPostalAddress_printable_address& msgData;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_UnformattedPostalAddress_printable_address (ASN1T_UnformattedPostalAddress_printable_address& data);
   ASN1C_UnformattedPostalAddress_printable_address (
      ASN1MessageBufferIF& msgBuf, ASN1T_UnformattedPostalAddress_printable_address& data);
   ASN1C_UnformattedPostalAddress_printable_address (ASN1C_UnformattedPostalAddress_printable_address& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_UnformattedPostalAddress_printable_address& getCopy (ASN1T_UnformattedPostalAddress_printable_address* pDstData = 0);
   ASN1T_UnformattedPostalAddress_printable_address* newCopy ();

   ASN1C_UnformattedPostalAddress_printable_address& operator= (ASN1C_UnformattedPostalAddress_printable_address& srcData);

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_UnformattedPostalAddress_printable_address (ASN1CTXT* pctxt,
   ASN1T_UnformattedPostalAddress_printable_address *pvalue, ASN1TagType tagging);

EXTERN int asn1D_UnformattedPostalAddress_printable_address (ASN1CTXT* pctxt,
   ASN1T_UnformattedPostalAddress_printable_address *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_UnformattedPostalAddress_printable_address
  (ASN1CTXT* pctxt, ASN1T_UnformattedPostalAddress_printable_address* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_UnformattedPostalAddress_printable_address (ASN1CTXT *pctxt, ASN1T_UnformattedPostalAddress_printable_address* pSrcValue, ASN1T_UnformattedPostalAddress_printable_address* pDstValue);

EXTERN void asn1Free_UnformattedPostalAddress_printable_address (ASN1CTXT *pctxt, ASN1T_UnformattedPostalAddress_printable_address* pvalue);

/**************************************************************/
/*                                                            */
/*  UnformattedPostalAddress                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_UnformattedPostalAddress;

typedef struct EXTERN ASN1T_UnformattedPostalAddress : public ASN1TPDU {
   struct {
      unsigned printable_addressPresent : 1;
      unsigned teletex_stringPresent : 1;
   } m;
   ASN1T_UnformattedPostalAddress_printable_address printable_address;
   ASN1T61String teletex_string;
   ASN1T_UnformattedPostalAddress ();
   ASN1T_UnformattedPostalAddress (ASN1C_UnformattedPostalAddress& srcData);
   ~ASN1T_UnformattedPostalAddress ();
} ASN1T_UnformattedPostalAddress;

class EXTERN ASN1C_UnformattedPostalAddress :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_UnformattedPostalAddress& msgData;
   struct ElementID {
      enum {
         _unknown, printable_address, teletex_string
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_UnformattedPostalAddress_printable_address* mpPrintable_addressC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_UnformattedPostalAddress (ASN1T_UnformattedPostalAddress& data);
   ASN1C_UnformattedPostalAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_UnformattedPostalAddress& data);
   ASN1C_UnformattedPostalAddress (ASN1C_UnformattedPostalAddress& original);

   ~ASN1C_UnformattedPostalAddress();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_UnformattedPostalAddress& getCopy (ASN1T_UnformattedPostalAddress* pDstData = 0);
   ASN1T_UnformattedPostalAddress* newCopy ();

   inline ASN1C_UnformattedPostalAddress& operator= (ASN1C_UnformattedPostalAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_UnformattedPostalAddress (ASN1CTXT* pctxt,
   ASN1T_UnformattedPostalAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_UnformattedPostalAddress (ASN1CTXT* pctxt,
   ASN1T_UnformattedPostalAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_UnformattedPostalAddress
  (ASN1CTXT* pctxt, ASN1T_UnformattedPostalAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_UnformattedPostalAddress (ASN1CTXT *pctxt, ASN1T_UnformattedPostalAddress* pSrcValue, ASN1T_UnformattedPostalAddress* pDstValue);

EXTERN void asn1Free_UnformattedPostalAddress (ASN1CTXT *pctxt, ASN1T_UnformattedPostalAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtendedNetworkAddress_e163_4_address                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ExtendedNetworkAddress_e163_4_address;

typedef struct EXTERN ASN1T_ExtendedNetworkAddress_e163_4_address : public ASN1TPDU {
   struct {
      unsigned sub_addressPresent : 1;
   } m;
   ASN1NumericString number;
   ASN1NumericString sub_address;
   ASN1T_ExtendedNetworkAddress_e163_4_address ();
   ASN1T_ExtendedNetworkAddress_e163_4_address (ASN1C_ExtendedNetworkAddress_e163_4_address& srcData);
   ~ASN1T_ExtendedNetworkAddress_e163_4_address ();
} ASN1T_ExtendedNetworkAddress_e163_4_address;

class EXTERN ASN1C_ExtendedNetworkAddress_e163_4_address :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ExtendedNetworkAddress_e163_4_address& msgData;
   struct ElementID {
      enum {
         _unknown, number, sub_address
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_ExtendedNetworkAddress_e163_4_address (ASN1T_ExtendedNetworkAddress_e163_4_address& data);
   ASN1C_ExtendedNetworkAddress_e163_4_address (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtendedNetworkAddress_e163_4_address& data);
   ASN1C_ExtendedNetworkAddress_e163_4_address (ASN1C_ExtendedNetworkAddress_e163_4_address& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtendedNetworkAddress_e163_4_address& getCopy (ASN1T_ExtendedNetworkAddress_e163_4_address* pDstData = 0);
   ASN1T_ExtendedNetworkAddress_e163_4_address* newCopy ();

   inline ASN1C_ExtendedNetworkAddress_e163_4_address& operator= (ASN1C_ExtendedNetworkAddress_e163_4_address& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ExtendedNetworkAddress_e163_4_address (ASN1CTXT* pctxt,
   ASN1T_ExtendedNetworkAddress_e163_4_address *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtendedNetworkAddress_e163_4_address (ASN1CTXT* pctxt,
   ASN1T_ExtendedNetworkAddress_e163_4_address *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtendedNetworkAddress_e163_4_address
  (ASN1CTXT* pctxt, ASN1T_ExtendedNetworkAddress_e163_4_address* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtendedNetworkAddress_e163_4_address (ASN1CTXT *pctxt, ASN1T_ExtendedNetworkAddress_e163_4_address* pSrcValue, ASN1T_ExtendedNetworkAddress_e163_4_address* pDstValue);

EXTERN void asn1Free_ExtendedNetworkAddress_e163_4_address (ASN1CTXT *pctxt, ASN1T_ExtendedNetworkAddress_e163_4_address* pvalue);

/**************************************************************/
/*                                                            */
/*  PresentationAddress_nAddresses                            */
/*                                                            */
/**************************************************************/

#define TV_PresentationAddress_nAddresses	(TM_CTXT|TM_CONS|3)

class EXTERN ASN1C_PresentationAddress_nAddresses;

typedef struct EXTERN ASN1T_PresentationAddress_nAddresses : public ASN1TPDU {
   ASN1UINT n;
   ASN1TDynOctStr *elem;
   ASN1T_PresentationAddress_nAddresses () : n (0), elem(NULL) {} // FIXED for PVS
   ASN1T_PresentationAddress_nAddresses (ASN1C_PresentationAddress_nAddresses& srcData);
   ~ASN1T_PresentationAddress_nAddresses ();
} ASN1T_PresentationAddress_nAddresses;

class EXTERN ASN1C_PresentationAddress_nAddresses :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PresentationAddress_nAddresses& msgData;
   Asn1RTDList tmpList;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_PresentationAddress_nAddresses (ASN1T_PresentationAddress_nAddresses& data);
   ASN1C_PresentationAddress_nAddresses (
      ASN1MessageBufferIF& msgBuf, ASN1T_PresentationAddress_nAddresses& data);
   ASN1C_PresentationAddress_nAddresses (ASN1C_PresentationAddress_nAddresses& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PresentationAddress_nAddresses& getCopy (ASN1T_PresentationAddress_nAddresses* pDstData = 0);
   ASN1T_PresentationAddress_nAddresses* newCopy ();

   ASN1C_PresentationAddress_nAddresses& operator= (ASN1C_PresentationAddress_nAddresses& srcData);
   virtual void finalize ();

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PresentationAddress_nAddresses (ASN1CTXT* pctxt,
   ASN1T_PresentationAddress_nAddresses *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PresentationAddress_nAddresses (ASN1CTXT* pctxt,
   ASN1T_PresentationAddress_nAddresses *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PresentationAddress_nAddresses
  (ASN1CTXT* pctxt, ASN1T_PresentationAddress_nAddresses* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PresentationAddress_nAddresses (ASN1CTXT *pctxt, ASN1T_PresentationAddress_nAddresses* pSrcValue, ASN1T_PresentationAddress_nAddresses* pDstValue);

EXTERN void asn1Free_PresentationAddress_nAddresses (ASN1CTXT *pctxt, ASN1T_PresentationAddress_nAddresses* pvalue);

/**************************************************************/
/*                                                            */
/*  PresentationAddress                                       */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PresentationAddress;

typedef struct EXTERN ASN1T_PresentationAddress : public ASN1TPDU {
   struct {
      unsigned pSelectorPresent : 1;
      unsigned sSelectorPresent : 1;
      unsigned tSelectorPresent : 1;
   } m;
   ASN1TDynOctStr pSelector;
   ASN1TDynOctStr sSelector;
   ASN1TDynOctStr tSelector;
   ASN1T_PresentationAddress_nAddresses nAddresses;
   ASN1T_PresentationAddress ();
   ASN1T_PresentationAddress (ASN1C_PresentationAddress& srcData);
   ~ASN1T_PresentationAddress ();
} ASN1T_PresentationAddress;

class EXTERN ASN1C_PresentationAddress :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PresentationAddress& msgData;
   struct ElementID {
      enum {
         _unknown, pSelector, sSelector, tSelector, nAddresses
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PresentationAddress_nAddresses* mpNAddressesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PresentationAddress (ASN1T_PresentationAddress& data);
   ASN1C_PresentationAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_PresentationAddress& data);
   ASN1C_PresentationAddress (ASN1C_PresentationAddress& original);

   ~ASN1C_PresentationAddress();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PresentationAddress& getCopy (ASN1T_PresentationAddress* pDstData = 0);
   ASN1T_PresentationAddress* newCopy ();

   inline ASN1C_PresentationAddress& operator= (ASN1C_PresentationAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PresentationAddress (ASN1CTXT* pctxt,
   ASN1T_PresentationAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PresentationAddress (ASN1CTXT* pctxt,
   ASN1T_PresentationAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PresentationAddress
  (ASN1CTXT* pctxt, ASN1T_PresentationAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PresentationAddress (ASN1CTXT *pctxt, ASN1T_PresentationAddress* pSrcValue, ASN1T_PresentationAddress* pDstValue);

EXTERN void asn1Free_PresentationAddress (ASN1CTXT *pctxt, ASN1T_PresentationAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  ExtendedNetworkAddress                                    */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_ExtendedNetworkAddress_e163_4_address 1
#define T_ExtendedNetworkAddress_psap_address 2

class EXTERN ASN1C_ExtendedNetworkAddress;

typedef struct EXTERN ASN1T_ExtendedNetworkAddress : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_ExtendedNetworkAddress_e163_4_address *e163_4_address;
      /* t = 2 */
      ASN1T_PresentationAddress *psap_address;
   } u;
   ASN1T_ExtendedNetworkAddress () {}
   ASN1T_ExtendedNetworkAddress (ASN1C_ExtendedNetworkAddress& srcData);
   ~ASN1T_ExtendedNetworkAddress ();
} ASN1T_ExtendedNetworkAddress;

class EXTERN ASN1C_ExtendedNetworkAddress :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ExtendedNetworkAddress& msgData;
   struct ElementID {
      enum {
         _unknown, e163_4_address, psap_address
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_ExtendedNetworkAddress_e163_4_address* mpE163_4_addressC;
   class ASN1C_PresentationAddress* mpPsap_addressC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_ExtendedNetworkAddress (ASN1T_ExtendedNetworkAddress& data);
   ASN1C_ExtendedNetworkAddress (
      ASN1MessageBufferIF& msgBuf, ASN1T_ExtendedNetworkAddress& data);
   ASN1C_ExtendedNetworkAddress (ASN1C_ExtendedNetworkAddress& original);

   ~ASN1C_ExtendedNetworkAddress();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_ExtendedNetworkAddress& getCopy (ASN1T_ExtendedNetworkAddress* pDstData = 0);
   ASN1T_ExtendedNetworkAddress* newCopy ();

   inline ASN1C_ExtendedNetworkAddress& operator= (ASN1C_ExtendedNetworkAddress& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_ExtendedNetworkAddress (ASN1CTXT* pctxt,
   ASN1T_ExtendedNetworkAddress *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ExtendedNetworkAddress (ASN1CTXT* pctxt,
   ASN1T_ExtendedNetworkAddress *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ExtendedNetworkAddress
  (ASN1CTXT* pctxt, ASN1T_ExtendedNetworkAddress* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ExtendedNetworkAddress (ASN1CTXT *pctxt, ASN1T_ExtendedNetworkAddress* pSrcValue, ASN1T_ExtendedNetworkAddress* pDstValue);

EXTERN void asn1Free_ExtendedNetworkAddress (ASN1CTXT *pctxt, ASN1T_ExtendedNetworkAddress* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexDomainDefinedAttribute                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TeletexDomainDefinedAttribute;

typedef struct EXTERN ASN1T_TeletexDomainDefinedAttribute : public ASN1TPDU {
   ASN1T61String type;
   ASN1T61String value;
   ASN1T_TeletexDomainDefinedAttribute ();
   ASN1T_TeletexDomainDefinedAttribute (ASN1C_TeletexDomainDefinedAttribute& srcData);
   ~ASN1T_TeletexDomainDefinedAttribute ();
} ASN1T_TeletexDomainDefinedAttribute;

class EXTERN ASN1C_TeletexDomainDefinedAttribute :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexDomainDefinedAttribute& msgData;
   struct ElementID {
      enum {
         _unknown, type, value
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_TeletexDomainDefinedAttribute (ASN1T_TeletexDomainDefinedAttribute& data);
   ASN1C_TeletexDomainDefinedAttribute (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexDomainDefinedAttribute& data);
   ASN1C_TeletexDomainDefinedAttribute (ASN1C_TeletexDomainDefinedAttribute& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexDomainDefinedAttribute& getCopy (ASN1T_TeletexDomainDefinedAttribute* pDstData = 0);
   ASN1T_TeletexDomainDefinedAttribute* newCopy ();

   inline ASN1C_TeletexDomainDefinedAttribute& operator= (ASN1C_TeletexDomainDefinedAttribute& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TeletexDomainDefinedAttribute (ASN1CTXT* pctxt,
   ASN1T_TeletexDomainDefinedAttribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexDomainDefinedAttribute (ASN1CTXT* pctxt,
   ASN1T_TeletexDomainDefinedAttribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexDomainDefinedAttribute
  (ASN1CTXT* pctxt, ASN1T_TeletexDomainDefinedAttribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexDomainDefinedAttribute (ASN1CTXT *pctxt, ASN1T_TeletexDomainDefinedAttribute* pSrcValue, ASN1T_TeletexDomainDefinedAttribute* pDstValue);

EXTERN void asn1Free_TeletexDomainDefinedAttribute (ASN1CTXT *pctxt, ASN1T_TeletexDomainDefinedAttribute* pvalue);

/**************************************************************/
/*                                                            */
/*  TeletexDomainDefinedAttributes                            */
/*                                                            */
/**************************************************************/

/* List of ASN1T_TeletexDomainDefinedAttribute */
typedef struct EXTERN ASN1T_TeletexDomainDefinedAttributes : public ASN1TPDUSeqOfList {
   ~ASN1T_TeletexDomainDefinedAttributes();
} ASN1T_TeletexDomainDefinedAttributes;

class EXTERN ASN1C_TeletexDomainDefinedAttributes :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TeletexDomainDefinedAttributes& msgData;
   ASN1T_TeletexDomainDefinedAttribute *mpElement;
   class ASN1C_TeletexDomainDefinedAttribute* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_TeletexDomainDefinedAttributes (ASN1T_TeletexDomainDefinedAttributes& data);
   ASN1C_TeletexDomainDefinedAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_TeletexDomainDefinedAttributes& data);
   ASN1C_TeletexDomainDefinedAttributes (ASN1C_TeletexDomainDefinedAttributes& original);

   ~ASN1C_TeletexDomainDefinedAttributes();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_TeletexDomainDefinedAttributes& getCopy (ASN1T_TeletexDomainDefinedAttributes* pDstData = 0);
   ASN1T_TeletexDomainDefinedAttributes* newCopy ();

   ASN1C_TeletexDomainDefinedAttributes& operator= (ASN1C_TeletexDomainDefinedAttributes& srcData);
   void Append (ASN1T_TeletexDomainDefinedAttribute * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_TeletexDomainDefinedAttributes (ASN1CTXT* pctxt,
   ASN1T_TeletexDomainDefinedAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TeletexDomainDefinedAttributes (ASN1CTXT* pctxt,
   ASN1T_TeletexDomainDefinedAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TeletexDomainDefinedAttributes
  (ASN1CTXT* pctxt, ASN1T_TeletexDomainDefinedAttributes* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TeletexDomainDefinedAttributes (ASN1CTXT *pctxt, ASN1T_TeletexDomainDefinedAttributes* pSrcValue, ASN1T_TeletexDomainDefinedAttributes* pDstValue);

EXTERN void asn1Free_TeletexDomainDefinedAttributes (ASN1CTXT *pctxt, ASN1T_TeletexDomainDefinedAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  RsaPubKey                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RsaPubKey;

typedef struct EXTERN ASN1T_RsaPubKey : public ASN1TPDU {
   ASN1T_RsaModulus modulus;
   ASN1INT pubexp;
   ASN1T_RsaPubKey ();
   ASN1T_RsaPubKey (ASN1C_RsaPubKey& srcData);
} ASN1T_RsaPubKey;

class EXTERN ASN1C_RsaPubKey :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_RsaPubKey& msgData;
   struct ElementID {
      enum {
         _unknown, modulus, pubexp
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_RsaPubKey (ASN1T_RsaPubKey& data);
   ASN1C_RsaPubKey (
      ASN1MessageBufferIF& msgBuf, ASN1T_RsaPubKey& data);
   ASN1C_RsaPubKey (ASN1C_RsaPubKey& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_RsaPubKey& getCopy (ASN1T_RsaPubKey* pDstData = 0);
   ASN1T_RsaPubKey* newCopy ();

   inline ASN1C_RsaPubKey& operator= (ASN1C_RsaPubKey& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_RsaPubKey (ASN1CTXT* pctxt,
   ASN1T_RsaPubKey *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RsaPubKey (ASN1CTXT* pctxt,
   ASN1T_RsaPubKey *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RsaPubKey
  (ASN1CTXT* pctxt, ASN1T_RsaPubKey* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RsaPubKey (ASN1CTXT *pctxt, ASN1T_RsaPubKey* pSrcValue, ASN1T_RsaPubKey* pDstValue);

/**************************************************************/
/*                                                            */
/*  RsaPrivateKeyCRTComponents                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RsaPrivateKeyCRTComponents;

typedef struct EXTERN ASN1T_RsaPrivateKeyCRTComponents : public ASN1TPDU {
   ASN1T_CRTComponent p;
   ASN1T_CRTComponent q;
   ASN1T_CRTComponent dp;
   ASN1T_CRTComponent dq;
   ASN1T_CRTComponent u;
   ASN1T_RsaPrivateKeyCRTComponents ();
   ASN1T_RsaPrivateKeyCRTComponents (ASN1C_RsaPrivateKeyCRTComponents& srcData);
} ASN1T_RsaPrivateKeyCRTComponents;

class EXTERN ASN1C_RsaPrivateKeyCRTComponents :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_RsaPrivateKeyCRTComponents& msgData;
   struct ElementID {
      enum {
         _unknown, p, q, dp, dq, u
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_RsaPrivateKeyCRTComponents (ASN1T_RsaPrivateKeyCRTComponents& data);
   ASN1C_RsaPrivateKeyCRTComponents (
      ASN1MessageBufferIF& msgBuf, ASN1T_RsaPrivateKeyCRTComponents& data);
   ASN1C_RsaPrivateKeyCRTComponents (ASN1C_RsaPrivateKeyCRTComponents& original);

   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_RsaPrivateKeyCRTComponents& getCopy (ASN1T_RsaPrivateKeyCRTComponents* pDstData = 0);
   ASN1T_RsaPrivateKeyCRTComponents* newCopy ();

   inline ASN1C_RsaPrivateKeyCRTComponents& operator= (ASN1C_RsaPrivateKeyCRTComponents& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_RsaPrivateKeyCRTComponents (ASN1CTXT* pctxt,
   ASN1T_RsaPrivateKeyCRTComponents *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RsaPrivateKeyCRTComponents (ASN1CTXT* pctxt,
   ASN1T_RsaPrivateKeyCRTComponents *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RsaPrivateKeyCRTComponents
  (ASN1CTXT* pctxt, ASN1T_RsaPrivateKeyCRTComponents* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RsaPrivateKeyCRTComponents (ASN1CTXT *pctxt, ASN1T_RsaPrivateKeyCRTComponents* pSrcValue, ASN1T_RsaPrivateKeyCRTComponents* pDstValue);

/**************************************************************/
/*                                                            */
/*  _SetOfPCI_Attribute                                       */
/*                                                            */
/**************************************************************/

/* List of ASN1T_PCI_Attribute */
typedef struct EXTERN ASN1T__SetOfPCI_Attribute : public ASN1TPDUSeqOfList {
   ~ASN1T__SetOfPCI_Attribute();
} ASN1T__SetOfPCI_Attribute;

class EXTERN ASN1C__SetOfPCI_Attribute :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__SetOfPCI_Attribute& msgData;
   ASN1T_PCI_Attribute *mpElement;
   class ASN1C_PCI_Attribute* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C__SetOfPCI_Attribute (ASN1T__SetOfPCI_Attribute& data);
   ASN1C__SetOfPCI_Attribute (
      ASN1MessageBufferIF& msgBuf, ASN1T__SetOfPCI_Attribute& data);
   ASN1C__SetOfPCI_Attribute (ASN1C__SetOfPCI_Attribute& original);

   ~ASN1C__SetOfPCI_Attribute();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T__SetOfPCI_Attribute& getCopy (ASN1T__SetOfPCI_Attribute* pDstData = 0);
   ASN1T__SetOfPCI_Attribute* newCopy ();

   ASN1C__SetOfPCI_Attribute& operator= (ASN1C__SetOfPCI_Attribute& srcData);
   void Append (ASN1T_PCI_Attribute * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E__SetOfPCI_Attribute (ASN1CTXT* pctxt,
   ASN1T__SetOfPCI_Attribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SetOfPCI_Attribute (ASN1CTXT* pctxt,
   ASN1T__SetOfPCI_Attribute *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__SetOfPCI_Attribute
  (ASN1CTXT* pctxt, ASN1T__SetOfPCI_Attribute* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__SetOfPCI_Attribute (ASN1CTXT *pctxt, ASN1T__SetOfPCI_Attribute* pSrcValue, ASN1T__SetOfPCI_Attribute* pDstValue);

EXTERN void asn1Free__SetOfPCI_Attribute (ASN1CTXT *pctxt, ASN1T__SetOfPCI_Attribute* pvalue);

/**************************************************************/
/*                                                            */
/*  PCI_HSM_CertificationRequestInfo                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PCI_HSM_CertificationRequestInfo;

typedef struct EXTERN ASN1T_PCI_HSM_CertificationRequestInfo : public ASN1TPDU {
   struct {
      unsigned attributesPresent : 1;
   } m;
   ASN1INT version;
   ASN1T_Name subject;
   ASN1T_SubjectPublicKeyInfo subjectPublicKeyInfo;
   ASN1T__SetOfPCI_Attribute attributes;
   ASN1T_PCI_HSM_CertificationRequestInfo ();
   ASN1T_PCI_HSM_CertificationRequestInfo (ASN1C_PCI_HSM_CertificationRequestInfo& srcData);
   ~ASN1T_PCI_HSM_CertificationRequestInfo ();
} ASN1T_PCI_HSM_CertificationRequestInfo;

class EXTERN ASN1C_PCI_HSM_CertificationRequestInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PCI_HSM_CertificationRequestInfo& msgData;
   struct ElementID {
      enum {
         _unknown, version, subject, subjectPublicKeyInfo, attributes
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Name* mpSubjectC;
   class ASN1C_SubjectPublicKeyInfo* mpSubjectPublicKeyInfoC;
   class ASN1C__SetOfPCI_Attribute* mpAttributesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PCI_HSM_CertificationRequestInfo (ASN1T_PCI_HSM_CertificationRequestInfo& data);
   ASN1C_PCI_HSM_CertificationRequestInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_PCI_HSM_CertificationRequestInfo& data);
   ASN1C_PCI_HSM_CertificationRequestInfo (ASN1C_PCI_HSM_CertificationRequestInfo& original);

   ~ASN1C_PCI_HSM_CertificationRequestInfo();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PCI_HSM_CertificationRequestInfo& getCopy (ASN1T_PCI_HSM_CertificationRequestInfo* pDstData = 0);
   ASN1T_PCI_HSM_CertificationRequestInfo* newCopy ();

   inline ASN1C_PCI_HSM_CertificationRequestInfo& operator= (ASN1C_PCI_HSM_CertificationRequestInfo& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PCI_HSM_CertificationRequestInfo (ASN1CTXT* pctxt,
   ASN1T_PCI_HSM_CertificationRequestInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PCI_HSM_CertificationRequestInfo (ASN1CTXT* pctxt,
   ASN1T_PCI_HSM_CertificationRequestInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PCI_HSM_CertificationRequestInfo
  (ASN1CTXT* pctxt, ASN1T_PCI_HSM_CertificationRequestInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PCI_HSM_CertificationRequestInfo (ASN1CTXT *pctxt, ASN1T_PCI_HSM_CertificationRequestInfo* pSrcValue, ASN1T_PCI_HSM_CertificationRequestInfo* pDstValue);

EXTERN void asn1Free_PCI_HSM_CertificationRequestInfo (ASN1CTXT *pctxt, ASN1T_PCI_HSM_CertificationRequestInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  PCI_HSM_CertificationRequest                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PCI_HSM_CertificationRequest;

typedef struct EXTERN ASN1T_PCI_HSM_CertificationRequest : public ASN1TPDU {
   ASN1T_PCI_HSM_CertificationRequestInfo certificationRequestInfo;
   ASN1T_AlgorithmIdentifier signatureAlgorithm;
   ASN1TDynBitStr signature;
   ASN1T_PCI_HSM_CertificationRequest ();
   ASN1T_PCI_HSM_CertificationRequest (ASN1C_PCI_HSM_CertificationRequest& srcData);
   ~ASN1T_PCI_HSM_CertificationRequest ();
} ASN1T_PCI_HSM_CertificationRequest;

class EXTERN ASN1C_PCI_HSM_CertificationRequest :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PCI_HSM_CertificationRequest& msgData;
   struct ElementID {
      enum {
         _unknown, certificationRequestInfo, signatureAlgorithm, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PCI_HSM_CertificationRequestInfo* mpCertificationRequestInfoC;
   class ASN1C_AlgorithmIdentifier* mpSignatureAlgorithmC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PCI_HSM_CertificationRequest (ASN1T_PCI_HSM_CertificationRequest& data);
   ASN1C_PCI_HSM_CertificationRequest (
      ASN1MessageBufferIF& msgBuf, ASN1T_PCI_HSM_CertificationRequest& data);
   ASN1C_PCI_HSM_CertificationRequest (ASN1C_PCI_HSM_CertificationRequest& original);

   ~ASN1C_PCI_HSM_CertificationRequest();
   // standard encode/decode methods (defined in ASN1CType base class):
   // int Encode ();
   // int Decode ();

   // stream encode/decode methods:
   int EncodeTo (ASN1MessageBufferIF& msgBuf);
   int DecodeFrom (ASN1MessageBufferIF& msgBuf);

   ASN1T_PCI_HSM_CertificationRequest& getCopy (ASN1T_PCI_HSM_CertificationRequest* pDstData = 0);
   ASN1T_PCI_HSM_CertificationRequest* newCopy ();

   inline ASN1C_PCI_HSM_CertificationRequest& operator= (ASN1C_PCI_HSM_CertificationRequest& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }

   // SAX ContentHandler interface

   virtual void startElement 
      (const XMLCHAR* const uri, 
       const XMLCHAR* const localname, 
       const XMLCHAR* const qname, 
       const XMLCHAR* const* attrs);

   virtual void characters 
      (const XMLCHAR* const chars,
       const unsigned int length);

   virtual void endElement
      (const XMLCHAR* const uri,
       const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   virtual void init (int level = 0);
} ;

EXTERN int asn1E_PCI_HSM_CertificationRequest (ASN1CTXT* pctxt,
   ASN1T_PCI_HSM_CertificationRequest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PCI_HSM_CertificationRequest (ASN1CTXT* pctxt,
   ASN1T_PCI_HSM_CertificationRequest *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PCI_HSM_CertificationRequest
  (ASN1CTXT* pctxt, ASN1T_PCI_HSM_CertificationRequest* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PCI_HSM_CertificationRequest (ASN1CTXT *pctxt, ASN1T_PCI_HSM_CertificationRequest* pSrcValue, ASN1T_PCI_HSM_CertificationRequest* pDstValue);

EXTERN void asn1Free_PCI_HSM_CertificationRequest (ASN1CTXT *pctxt, ASN1T_PCI_HSM_CertificationRequest* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_pkix;
extern EXTERN ASN1OBJID id_pe;
extern EXTERN ASN1OBJID id_qt;
extern EXTERN ASN1OBJID id_kp;
extern EXTERN ASN1OBJID id_ad;
extern EXTERN ASN1OBJID id_qt_cps;
extern EXTERN ASN1OBJID id_qt_unotice;
extern EXTERN ASN1OBJID id_ad_ocsp;
extern EXTERN ASN1OBJID id_ad_caIssuers;
extern EXTERN ASN1OBJID id_ad_caRepository;
extern EXTERN ASN1OBJID id_ad_timeStamping;
extern EXTERN ASN1OBJID id_ms;
extern EXTERN ASN1OBJID id_ms_certExtensions;
extern EXTERN ASN1OBJID id_ms_enrollmentCSP;
extern EXTERN ASN1OBJID id_ms_osVersion;
extern EXTERN ASN1OBJID id_contentType;
extern EXTERN ASN1OBJID id_messageDigest;
extern EXTERN ASN1OBJID id_signingTime;
extern EXTERN ASN1OBJID id_countersignature;
extern EXTERN ASN1OBJID id_at_domainComponent;
extern EXTERN ASN1OBJID pkcs_9;
extern EXTERN ASN1OBJID emailAddress;
extern EXTERN ASN1OBJID pkcs9_unstructuredName;
extern EXTERN ASN1OBJID id_at_commonName;
extern EXTERN ASN1OBJID id_at_surname;
extern EXTERN ASN1OBJID id_at_serialNumber;
extern EXTERN ASN1OBJID id_at_countryName;
extern EXTERN ASN1OBJID id_at_localityName;
extern EXTERN ASN1OBJID id_at_stateOrProvinceName;
extern EXTERN ASN1OBJID id_at_streetAddress;
extern EXTERN ASN1OBJID id_at_organizationName;
extern EXTERN ASN1OBJID id_at_organizationalUnitName;
extern EXTERN ASN1OBJID id_at_title;
extern EXTERN ASN1OBJID id_at_name;
extern EXTERN ASN1OBJID id_at_givenName;
extern EXTERN ASN1OBJID id_at_initials;
extern EXTERN ASN1OBJID id_at_generationQualifier;
extern EXTERN ASN1OBJID id_at_dnQualifier;
extern EXTERN ASN1OBJID id_at_pseudonym;
extern EXTERN ASN1OBJID id_at_postalAddress;
extern EXTERN ASN1OBJID id_at_postalCode;
#define ASN1V_common_name 1
#define ASN1V_teletex_common_name 2
#define ASN1V_teletex_organization_name 3
#define ASN1V_teletex_personal_name 4
#define ASN1V_teletex_organizational_unit_names 5
#define ASN1V_pds_name 7
#define ASN1V_physical_delivery_country_name 8
#define ASN1V_postal_code 9
#define ASN1V_physical_delivery_office_name 10
#define ASN1V_physical_delivery_office_number 11
#define ASN1V_extension_OR_address_components 12
#define ASN1V_physical_delivery_personal_name 13
#define ASN1V_physical_delivery_organization_name 14
#define ASN1V_extension_physical_delivery_address_components 15
#define ASN1V_unformatted_postal_address 16
#define ASN1V_street_address 17
#define ASN1V_post_office_box_address 18
#define ASN1V_poste_restante_address 19
#define ASN1V_unique_postal_name 20
#define ASN1V_local_postal_attributes 21
#define ASN1V_extended_network_address 22
#define ASN1V_terminal_type 23
#define ASN1V_teletex_domain_defined_attributes 6
#define ASN1V_ub_name 32768
#define ASN1V_ub_common_name 32768
#define ASN1V_ub_unstructured_name 32768
#define ASN1V_ub_locality_name 32768
#define ASN1V_ub_street_address 32768
#define ASN1V_ub_state_name 32768
#define ASN1V_ub_organization_name 32768
#define ASN1V_ub_organizational_unit_name 32768
#define ASN1V_ub_title 32768
#define ASN1V_ub_match 32768
#define ASN1V_ub_emailaddress_length 32768
#define ASN1V_ub_common_name_length 32768
#define ASN1V_ub_unstructured_name_length 32768
#define ASN1V_ub_country_name_alpha_length 32768
#define ASN1V_ub_country_name_numeric_length 32768
#define ASN1V_ub_domain_defined_attributes 4
#define ASN1V_ub_domain_defined_attribute_type_length 32768
#define ASN1V_ub_domain_defined_attribute_value_length 32768
#define ASN1V_ub_domain_name_length 32768
#define ASN1V_ub_extension_attributes 256
#define ASN1V_ub_e163_4_number_length 32768
#define ASN1V_ub_e163_4_sub_address_length 32768
#define ASN1V_ub_generation_qualifier_length 32768
#define ASN1V_ub_given_name_length 32768
#define ASN1V_ub_initials_length 32768
#define ASN1V_ub_integer_options 256
#define ASN1V_ub_numeric_user_id_length 32768
#define ASN1V_ub_organization_name_length 32768
#define ASN1V_ub_organizational_unit_name_length 32768
#define ASN1V_ub_organizational_units 4
#define ASN1V_ub_pds_name_length 32768
#define ASN1V_ub_pds_parameter_length 32768
#define ASN1V_ub_pds_physical_address_lines 6
#define ASN1V_ub_postal_code_length 32768
#define ASN1V_ub_surname_length 32768
#define ASN1V_ub_terminal_id_length 32768
#define ASN1V_ub_unformatted_address_length 32768
#define ASN1V_ub_x121_address_length 32768
#define ASN1V_ub_pseudonym 32768
#define ASN1V_ub_postal_address 6
#define ASN1V_ub_postal_string 32768
#define ASN1V_ub_postal_code 32768
extern EXTERN ASN1OBJID id_aa_signingCertificate;
extern EXTERN ASN1OBJID id_aa_signingCertificateV2;
extern EXTERN ASN1OBJID id_sha256;
extern EXTERN ASN1OBJID id_sha384;
extern EXTERN ASN1OBJID id_sha512;
extern EXTERN ASN1OBJID id_sha224;
extern EXTERN ASN1OBJID md2;
extern EXTERN ASN1OBJID md4;
extern EXTERN ASN1OBJID md5;
extern EXTERN ASN1OBJID mdc2;
extern EXTERN ASN1OBJID id_hmacWithSHA224;
extern EXTERN ASN1OBJID id_hmacWithSHA256;
extern EXTERN ASN1OBJID id_hmacWithSHA384;
extern EXTERN ASN1OBJID id_hmacWithSHA512;
extern EXTERN ASN1OBJID id_aa_ets_otherSigCert;
extern EXTERN ASN1OBJID pkcs_9_at_extensionRequest;

}
#endif
