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

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

/**************************************************************/
/*                                                            */
/*  KeyIdentifier                                             */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_KeyIdentifier;

class EXTERN ASN1C_KeyIdentifier :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_KeyIdentifier& msgData;
public:
   ASN1C_KeyIdentifier (ASN1T_KeyIdentifier& data);
   ASN1C_KeyIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_KeyIdentifier& data);
   ASN1C_KeyIdentifier (ASN1C_KeyIdentifier& 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_KeyIdentifier& getCopy (ASN1T_KeyIdentifier* pDstData = 0);
   ASN1T_KeyIdentifier* newCopy ();

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

EXTERN int asn1E_KeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_KeyIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_KeyIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_KeyIdentifier
  (ASN1CTXT* pctxt, ASN1T_KeyIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_KeyIdentifier (ASN1CTXT *pctxt, ASN1T_KeyIdentifier* pSrcValue, ASN1T_KeyIdentifier* pDstValue);

EXTERN void asn1Free_KeyIdentifier (ASN1CTXT *pctxt, ASN1T_KeyIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  SubjectKeyIdentifier                                      */
/*                                                            */
/**************************************************************/

typedef ASN1T_KeyIdentifier ASN1T_SubjectKeyIdentifier;

class EXTERN ASN1C_SubjectKeyIdentifier :
   public ASN1C_KeyIdentifier
{
protected:
public:
   ASN1C_SubjectKeyIdentifier (ASN1T_SubjectKeyIdentifier& data);
   ASN1C_SubjectKeyIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_SubjectKeyIdentifier& data);
   ASN1C_SubjectKeyIdentifier (ASN1C_SubjectKeyIdentifier& 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_SubjectKeyIdentifier& getCopy (ASN1T_SubjectKeyIdentifier* pDstData = 0);
   ASN1T_SubjectKeyIdentifier* newCopy ();

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

EXTERN int asn1E_SubjectKeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_SubjectKeyIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SubjectKeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_SubjectKeyIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SubjectKeyIdentifier
  (ASN1CTXT* pctxt, ASN1T_SubjectKeyIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SubjectKeyIdentifier (ASN1CTXT *pctxt, ASN1T_SubjectKeyIdentifier* pSrcValue, ASN1T_SubjectKeyIdentifier* pDstValue);

EXTERN void asn1Free_SubjectKeyIdentifier (ASN1CTXT *pctxt, ASN1T_SubjectKeyIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  KeyUsage                                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_KeyUsage;

typedef struct EXTERN ASN1T_KeyUsage {
   ASN1UINT  numbits;
   ASN1OCTET data[2];
   // ctors
   ASN1T_KeyUsage () : numbits(0) {}
   ASN1T_KeyUsage (ASN1UINT _numbits, const ASN1OCTET* _data) :
      numbits(_numbits) {
      memcpy (data, _data, sizeof(data));
   }
   ASN1T_KeyUsage (ASN1C_KeyUsage& srcData);
} ASN1T_KeyUsage;

class EXTERN ASN1C_KeyUsage :
   public ASN1CBitStr, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_KeyUsage& msgData;
public:
   // named bits
   enum { digitalSignature = 0, nonRepudiation = 1, keyEncipherment = 2, dataEncipherment = 3, keyAgreement = 4, keyCertSign = 5, cRLSign = 6, encipherOnly = 7, decipherOnly = 8 };

   ASN1C_KeyUsage (ASN1T_KeyUsage& data);
   ASN1C_KeyUsage (
      ASN1MessageBufferIF& msgBuf, ASN1T_KeyUsage& data);
   ASN1C_KeyUsage (ASN1C_KeyUsage& 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_KeyUsage& getCopy (ASN1T_KeyUsage* pDstData = 0);
   ASN1T_KeyUsage* newCopy ();

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

EXTERN int asn1E_KeyUsage (ASN1CTXT* pctxt,
   ASN1T_KeyUsage *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyUsage (ASN1CTXT* pctxt,
   ASN1T_KeyUsage *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_KeyUsage
  (ASN1CTXT* pctxt, ASN1T_KeyUsage* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_KeyUsage (ASN1CTXT *pctxt, ASN1T_KeyUsage* pSrcValue, ASN1T_KeyUsage* pDstValue);

/**************************************************************/
/*                                                            */
/*  KeyPurposeId                                              */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_KeyPurposeId;

class EXTERN ASN1C_KeyPurposeId :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_KeyPurposeId& msgData;
public:
   ASN1C_KeyPurposeId (ASN1T_KeyPurposeId& data);
   ASN1C_KeyPurposeId (
      ASN1MessageBufferIF& msgBuf, ASN1T_KeyPurposeId& data);
   ASN1C_KeyPurposeId (ASN1C_KeyPurposeId& 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_KeyPurposeId& getCopy (ASN1T_KeyPurposeId* pDstData = 0);
   ASN1T_KeyPurposeId* newCopy ();

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

EXTERN int asn1E_KeyPurposeId (ASN1CTXT* pctxt,
   ASN1T_KeyPurposeId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyPurposeId (ASN1CTXT* pctxt,
   ASN1T_KeyPurposeId *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_KeyPurposeId
  (ASN1CTXT* pctxt, ASN1T_KeyPurposeId* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_KeyPurposeId (ASN1CTXT *pctxt, ASN1T_KeyPurposeId* pSrcValue, ASN1T_KeyPurposeId* pDstValue);

/**************************************************************/
/*                                                            */
/*  CertPolicyId                                              */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_CertPolicyId;

class EXTERN ASN1C_CertPolicyId :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertPolicyId& msgData;
public:
   ASN1C_CertPolicyId (ASN1T_CertPolicyId& data);
   ASN1C_CertPolicyId (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertPolicyId& data);
   ASN1C_CertPolicyId (ASN1C_CertPolicyId& 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_CertPolicyId& getCopy (ASN1T_CertPolicyId* pDstData = 0);
   ASN1T_CertPolicyId* newCopy ();

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

EXTERN int asn1E_CertPolicyId (ASN1CTXT* pctxt,
   ASN1T_CertPolicyId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertPolicyId (ASN1CTXT* pctxt,
   ASN1T_CertPolicyId *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertPolicyId
  (ASN1CTXT* pctxt, ASN1T_CertPolicyId* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertPolicyId (ASN1CTXT *pctxt, ASN1T_CertPolicyId* pSrcValue, ASN1T_CertPolicyId* pDstValue);

/**************************************************************/
/*                                                            */
/*  CPSuri                                                    */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_CPSuri;

class EXTERN ASN1C_CPSuri :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CPSuri& msgData;
public:
   ASN1C_CPSuri (ASN1T_CPSuri& data);
   ASN1C_CPSuri (
      ASN1MessageBufferIF& msgBuf, ASN1T_CPSuri& data);
   ASN1C_CPSuri (ASN1C_CPSuri& 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_CPSuri& getCopy (ASN1T_CPSuri* pDstData = 0);
   ASN1T_CPSuri* newCopy ();

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

EXTERN int asn1E_CPSuri (ASN1CTXT* pctxt,
   ASN1T_CPSuri *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CPSuri (ASN1CTXT* pctxt,
   ASN1T_CPSuri *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CPSuri
  (ASN1CTXT* pctxt, ASN1T_CPSuri value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CPSuri (ASN1CTXT *pctxt, ASN1T_CPSuri* pSrcValue, ASN1T_CPSuri* pDstValue);

EXTERN void asn1Free_CPSuri (ASN1CTXT *pctxt, ASN1T_CPSuri* pvalue);

/**************************************************************/
/*                                                            */
/*  BaseDistance                                              */
/*                                                            */
/**************************************************************/

typedef ASN1UINT ASN1T_BaseDistance;

class EXTERN ASN1C_BaseDistance :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BaseDistance& msgData;
public:
   ASN1C_BaseDistance (ASN1T_BaseDistance& data);
   ASN1C_BaseDistance (
      ASN1MessageBufferIF& msgBuf, ASN1T_BaseDistance& data);
   ASN1C_BaseDistance (ASN1C_BaseDistance& 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_BaseDistance& getCopy (ASN1T_BaseDistance* pDstData = 0);
   ASN1T_BaseDistance* newCopy ();

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

EXTERN int asn1E_BaseDistance (ASN1CTXT* pctxt,
   ASN1T_BaseDistance *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BaseDistance (ASN1CTXT* pctxt,
   ASN1T_BaseDistance *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BaseDistance
  (ASN1CTXT* pctxt, ASN1T_BaseDistance value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BaseDistance (ASN1CTXT *pctxt, ASN1T_BaseDistance* pSrcValue, ASN1T_BaseDistance* pDstValue);

/**************************************************************/
/*                                                            */
/*  BasicNameForms                                            */
/*                                                            */
/**************************************************************/

typedef ASN1TDynBitStr ASN1T_BasicNameForms;

class EXTERN ASN1C_BasicNameForms :
   public ASN1CBitStr, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BasicNameForms& msgData;
public:
   // named bits
   enum { rfc822Name = 0, dNSName = 1, x400Address = 2, directoryName = 3, ediPartyName = 4, uniformResourceIdentifier = 5, iPAddress = 6, registeredID = 7 };

   ASN1C_BasicNameForms (ASN1T_BasicNameForms& data);
   ASN1C_BasicNameForms (
      ASN1MessageBufferIF& msgBuf, ASN1T_BasicNameForms& data);
   ASN1C_BasicNameForms (ASN1C_BasicNameForms& 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_BasicNameForms& getCopy (ASN1T_BasicNameForms* pDstData = 0);
   ASN1T_BasicNameForms* newCopy ();

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

EXTERN int asn1E_BasicNameForms (ASN1CTXT* pctxt,
   ASN1T_BasicNameForms *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BasicNameForms (ASN1CTXT* pctxt,
   ASN1T_BasicNameForms *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BasicNameForms
  (ASN1CTXT* pctxt, ASN1T_BasicNameForms* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BasicNameForms (ASN1CTXT *pctxt, ASN1T_BasicNameForms* pSrcValue, ASN1T_BasicNameForms* pDstValue);

EXTERN void asn1Free_BasicNameForms (ASN1CTXT *pctxt, ASN1T_BasicNameForms* pvalue);

/**************************************************************/
/*                                                            */
/*  SkipCerts                                                 */
/*                                                            */
/**************************************************************/

typedef ASN1UINT ASN1T_SkipCerts;

class EXTERN ASN1C_SkipCerts :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SkipCerts& msgData;
public:
   ASN1C_SkipCerts (ASN1T_SkipCerts& data);
   ASN1C_SkipCerts (
      ASN1MessageBufferIF& msgBuf, ASN1T_SkipCerts& data);
   ASN1C_SkipCerts (ASN1C_SkipCerts& 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_SkipCerts& getCopy (ASN1T_SkipCerts* pDstData = 0);
   ASN1T_SkipCerts* newCopy ();

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

EXTERN int asn1E_SkipCerts (ASN1CTXT* pctxt,
   ASN1T_SkipCerts *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SkipCerts (ASN1CTXT* pctxt,
   ASN1T_SkipCerts *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SkipCerts
  (ASN1CTXT* pctxt, ASN1T_SkipCerts value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SkipCerts (ASN1CTXT *pctxt, ASN1T_SkipCerts* pSrcValue, ASN1T_SkipCerts* pDstValue);

/**************************************************************/
/*                                                            */
/*  CRLNumber                                                 */
/*                                                            */
/**************************************************************/

typedef ASN1ConstCharPtr ASN1T_CRLNumber;

class EXTERN ASN1C_CRLNumber :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CRLNumber& msgData;
public:
   ASN1C_CRLNumber (ASN1T_CRLNumber& data);
   ASN1C_CRLNumber (
      ASN1MessageBufferIF& msgBuf, ASN1T_CRLNumber& data);
   ASN1C_CRLNumber (ASN1C_CRLNumber& 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_CRLNumber& getCopy (ASN1T_CRLNumber* pDstData = 0);
   ASN1T_CRLNumber* newCopy ();

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

EXTERN int asn1E_CRLNumber (ASN1CTXT* pctxt,
   ASN1T_CRLNumber *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRLNumber (ASN1CTXT* pctxt,
   ASN1T_CRLNumber *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CRLNumber
  (ASN1CTXT* pctxt, ASN1T_CRLNumber value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CRLNumber (ASN1CTXT *pctxt, ASN1T_CRLNumber* pSrcValue, ASN1T_CRLNumber* pDstValue);

/**************************************************************/
/*                                                            */
/*  CRLReason                                                 */
/*                                                            */
/**************************************************************/

struct EXTERN CRLReason {
   enum Root {
      unspecified = 0,
      keyCompromise = 1,
      cACompromise = 2,
      affiliationChanged = 3,
      superseded = 4,
      cessationOfOperation = 5,
      certificateHold = 6,
      removeFromCRL = 8,
      privilegeWithdrawn = 9,
      aACompromise = 10
   } ;
} ;

typedef ASN1UINT ASN1T_CRLReason;

class EXTERN ASN1C_CRLReason :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CRLReason& msgData;
public:
   ASN1C_CRLReason (ASN1T_CRLReason& data);
   ASN1C_CRLReason (
      ASN1MessageBufferIF& msgBuf, ASN1T_CRLReason& data);
   ASN1C_CRLReason (ASN1C_CRLReason& 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_CRLReason& getCopy (ASN1T_CRLReason* pDstData = 0);
   ASN1T_CRLReason* newCopy ();

   inline ASN1C_CRLReason& operator= (ASN1C_CRLReason& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
   static int parseNamedValue (ASN1CTXT* pctxt, ASN1UINT* value);
} ;

EXTERN int asn1E_CRLReason (ASN1CTXT* pctxt,
   ASN1T_CRLReason *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRLReason (ASN1CTXT* pctxt,
   ASN1T_CRLReason *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CRLReason
  (ASN1CTXT* pctxt, ASN1T_CRLReason value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CRLReason (ASN1CTXT *pctxt, ASN1T_CRLReason* pSrcValue, ASN1T_CRLReason* pDstValue);

/**************************************************************/
/*                                                            */
/*  HoldInstruction                                           */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_HoldInstruction;

class EXTERN ASN1C_HoldInstruction :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_HoldInstruction& msgData;
public:
   ASN1C_HoldInstruction (ASN1T_HoldInstruction& data);
   ASN1C_HoldInstruction (
      ASN1MessageBufferIF& msgBuf, ASN1T_HoldInstruction& data);
   ASN1C_HoldInstruction (ASN1C_HoldInstruction& 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_HoldInstruction& getCopy (ASN1T_HoldInstruction* pDstData = 0);
   ASN1T_HoldInstruction* newCopy ();

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

EXTERN int asn1E_HoldInstruction (ASN1CTXT* pctxt,
   ASN1T_HoldInstruction *pvalue, ASN1TagType tagging);

EXTERN int asn1D_HoldInstruction (ASN1CTXT* pctxt,
   ASN1T_HoldInstruction *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_HoldInstruction
  (ASN1CTXT* pctxt, ASN1T_HoldInstruction* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_HoldInstruction (ASN1CTXT *pctxt, ASN1T_HoldInstruction* pSrcValue, ASN1T_HoldInstruction* pDstValue);

/**************************************************************/
/*                                                            */
/*  InvalidityDate                                            */
/*                                                            */
/**************************************************************/

typedef ASN1GeneralizedTime ASN1T_InvalidityDate;

class EXTERN ASN1C_InvalidityDate :
   public ASN1CGeneralizedTime, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_InvalidityDate& msgData;
public:
   ASN1C_InvalidityDate (ASN1T_InvalidityDate& data);
   ASN1C_InvalidityDate (
      ASN1MessageBufferIF& msgBuf, ASN1T_InvalidityDate& data);
   ASN1C_InvalidityDate (ASN1C_InvalidityDate& 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_InvalidityDate& getCopy (ASN1T_InvalidityDate* pDstData = 0);
   ASN1T_InvalidityDate* newCopy ();

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

EXTERN int asn1E_InvalidityDate (ASN1CTXT* pctxt,
   ASN1T_InvalidityDate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_InvalidityDate (ASN1CTXT* pctxt,
   ASN1T_InvalidityDate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_InvalidityDate
  (ASN1CTXT* pctxt, ASN1T_InvalidityDate value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_InvalidityDate (ASN1CTXT *pctxt, ASN1T_InvalidityDate* pSrcValue, ASN1T_InvalidityDate* pDstValue);

EXTERN void asn1Free_InvalidityDate (ASN1CTXT *pctxt, ASN1T_InvalidityDate* pvalue);

/**************************************************************/
/*                                                            */
/*  ReasonFlags                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ReasonFlags;

typedef struct EXTERN ASN1T_ReasonFlags {
   ASN1UINT  numbits;
   ASN1OCTET data[2];
   // ctors
   ASN1T_ReasonFlags () : numbits(0) {}
   ASN1T_ReasonFlags (ASN1UINT _numbits, const ASN1OCTET* _data) :
      numbits(_numbits) {
      memcpy (data, _data, sizeof(data));
   }
   ASN1T_ReasonFlags (ASN1C_ReasonFlags& srcData);
} ASN1T_ReasonFlags;

class EXTERN ASN1C_ReasonFlags :
   public ASN1CBitStr, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ReasonFlags& msgData;
public:
   // named bits
   enum { unused = 0, keyCompromise = 1, caCompromise = 2, affiliationChanged = 3, superseded = 4, cessationOfOperation = 5, certificateHold = 6, privilegeWithdrawn = 7, aACompromise = 8 };

   ASN1C_ReasonFlags (ASN1T_ReasonFlags& data);
   ASN1C_ReasonFlags (
      ASN1MessageBufferIF& msgBuf, ASN1T_ReasonFlags& data);
   ASN1C_ReasonFlags (ASN1C_ReasonFlags& 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_ReasonFlags& getCopy (ASN1T_ReasonFlags* pDstData = 0);
   ASN1T_ReasonFlags* newCopy ();

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

EXTERN int asn1E_ReasonFlags (ASN1CTXT* pctxt,
   ASN1T_ReasonFlags *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ReasonFlags (ASN1CTXT* pctxt,
   ASN1T_ReasonFlags *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ReasonFlags
  (ASN1CTXT* pctxt, ASN1T_ReasonFlags* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ReasonFlags (ASN1CTXT *pctxt, ASN1T_ReasonFlags* pSrcValue, ASN1T_ReasonFlags* pDstValue);

/**************************************************************/
/*                                                            */
/*  GeneralName_otherName                                     */
/*                                                            */
/**************************************************************/

#define TV_GeneralName_otherName	(TM_CTXT|TM_CONS|0)

class EXTERN ASN1C_GeneralName_otherName;

typedef struct EXTERN ASN1T_GeneralName_otherName : public ASN1TPDU {
   ASN1TObjId type_id;
   ASN1TOpenType value;
   ASN1T_GeneralName_otherName ();
   ASN1T_GeneralName_otherName (ASN1C_GeneralName_otherName& srcData);
   ~ASN1T_GeneralName_otherName ();
} ASN1T_GeneralName_otherName;

class EXTERN ASN1C_GeneralName_otherName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_GeneralName_otherName& msgData;
   struct ElementID {
      enum {
         _unknown, type_id, 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_GeneralName_otherName (ASN1T_GeneralName_otherName& data);
   ASN1C_GeneralName_otherName (
      ASN1MessageBufferIF& msgBuf, ASN1T_GeneralName_otherName& data);
   ASN1C_GeneralName_otherName (ASN1C_GeneralName_otherName& original);

   ~ASN1C_GeneralName_otherName();
   // 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_GeneralName_otherName& getCopy (ASN1T_GeneralName_otherName* pDstData = 0);
   ASN1T_GeneralName_otherName* newCopy ();

   inline ASN1C_GeneralName_otherName& operator= (ASN1C_GeneralName_otherName& 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_GeneralName_otherName (ASN1CTXT* pctxt,
   ASN1T_GeneralName_otherName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GeneralName_otherName (ASN1CTXT* pctxt,
   ASN1T_GeneralName_otherName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_GeneralName_otherName
  (ASN1CTXT* pctxt, ASN1T_GeneralName_otherName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_GeneralName_otherName (ASN1CTXT *pctxt, ASN1T_GeneralName_otherName* pSrcValue, ASN1T_GeneralName_otherName* pDstValue);

EXTERN void asn1Free_GeneralName_otherName (ASN1CTXT *pctxt, ASN1T_GeneralName_otherName* pvalue);

/**************************************************************/
/*                                                            */
/*  QTDisplayText                                             */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_QTDisplayText_utf8String      1
#define T_QTDisplayText_ia5String       2
#define T_QTDisplayText_visibleString   3
#define T_QTDisplayText_bmpString       4

class EXTERN ASN1C_QTDisplayText;

typedef struct EXTERN ASN1T_QTDisplayText : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1IA5String ia5String;
      /* t = 3 */
      ASN1VisibleString visibleString;
      /* t = 4 */
      ASN1BMPString bmpString;
   } u;
   ASN1T_QTDisplayText () {}
   ASN1T_QTDisplayText (ASN1C_QTDisplayText& srcData);
   ~ASN1T_QTDisplayText ();
} ASN1T_QTDisplayText;

class EXTERN ASN1C_QTDisplayText :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_QTDisplayText& msgData;
   struct ElementID {
      enum {
         _unknown, utf8String, ia5String, visibleString, bmpString
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_QTDisplayText (ASN1T_QTDisplayText& data);
   ASN1C_QTDisplayText (
      ASN1MessageBufferIF& msgBuf, ASN1T_QTDisplayText& data);
   ASN1C_QTDisplayText (ASN1C_QTDisplayText& 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_QTDisplayText& getCopy (ASN1T_QTDisplayText* pDstData = 0);
   ASN1T_QTDisplayText* newCopy ();

   inline ASN1C_QTDisplayText& operator= (ASN1C_QTDisplayText& 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_QTDisplayText (ASN1CTXT* pctxt,
   ASN1T_QTDisplayText *pvalue, ASN1TagType tagging);

EXTERN int asn1D_QTDisplayText (ASN1CTXT* pctxt,
   ASN1T_QTDisplayText *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_QTDisplayText
  (ASN1CTXT* pctxt, ASN1T_QTDisplayText* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_QTDisplayText (ASN1CTXT *pctxt, ASN1T_QTDisplayText* pSrcValue, ASN1T_QTDisplayText* pDstValue);

EXTERN void asn1Free_QTDisplayText (ASN1CTXT *pctxt, ASN1T_QTDisplayText* pvalue);

/**************************************************************/
/*                                                            */
/*  QTNoticeReference_noticeNumbers                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_QTNoticeReference_noticeNumbers;

typedef struct EXTERN ASN1T_QTNoticeReference_noticeNumbers : public ASN1TPDU {
   ASN1UINT n;
   ASN1INT *elem;
   ASN1T_QTNoticeReference_noticeNumbers () : n (0), elem(NULL) {} // FIXED for PVS
   ASN1T_QTNoticeReference_noticeNumbers (ASN1C_QTNoticeReference_noticeNumbers& srcData);
   ~ASN1T_QTNoticeReference_noticeNumbers ();
} ASN1T_QTNoticeReference_noticeNumbers;

class EXTERN ASN1C_QTNoticeReference_noticeNumbers :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_QTNoticeReference_noticeNumbers& msgData;
   Asn1RTDList tmpList;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_QTNoticeReference_noticeNumbers (ASN1T_QTNoticeReference_noticeNumbers& data);
   ASN1C_QTNoticeReference_noticeNumbers (
      ASN1MessageBufferIF& msgBuf, ASN1T_QTNoticeReference_noticeNumbers& data);
   ASN1C_QTNoticeReference_noticeNumbers (ASN1C_QTNoticeReference_noticeNumbers& 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_QTNoticeReference_noticeNumbers& getCopy (ASN1T_QTNoticeReference_noticeNumbers* pDstData = 0);
   ASN1T_QTNoticeReference_noticeNumbers* newCopy ();

   ASN1C_QTNoticeReference_noticeNumbers& operator= (ASN1C_QTNoticeReference_noticeNumbers& 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_QTNoticeReference_noticeNumbers (ASN1CTXT* pctxt,
   ASN1T_QTNoticeReference_noticeNumbers *pvalue, ASN1TagType tagging);

EXTERN int asn1D_QTNoticeReference_noticeNumbers (ASN1CTXT* pctxt,
   ASN1T_QTNoticeReference_noticeNumbers *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_QTNoticeReference_noticeNumbers
  (ASN1CTXT* pctxt, ASN1T_QTNoticeReference_noticeNumbers* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_QTNoticeReference_noticeNumbers (ASN1CTXT *pctxt, ASN1T_QTNoticeReference_noticeNumbers* pSrcValue, ASN1T_QTNoticeReference_noticeNumbers* pDstValue);

EXTERN void asn1Free_QTNoticeReference_noticeNumbers (ASN1CTXT *pctxt, ASN1T_QTNoticeReference_noticeNumbers* pvalue);

/**************************************************************/
/*                                                            */
/*  QTNoticeReference                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_QTNoticeReference;

typedef struct EXTERN ASN1T_QTNoticeReference : public ASN1TPDU {
   ASN1T_QTDisplayText organization;
   ASN1T_QTNoticeReference_noticeNumbers noticeNumbers;
   ASN1T_QTNoticeReference ();
   ASN1T_QTNoticeReference (ASN1C_QTNoticeReference& srcData);
   ~ASN1T_QTNoticeReference ();
} ASN1T_QTNoticeReference;

class EXTERN ASN1C_QTNoticeReference :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_QTNoticeReference& msgData;
   struct ElementID {
      enum {
         _unknown, organization, noticeNumbers
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_QTDisplayText* mpOrganizationC;
   class ASN1C_QTNoticeReference_noticeNumbers* mpNoticeNumbersC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_QTNoticeReference (ASN1T_QTNoticeReference& data);
   ASN1C_QTNoticeReference (
      ASN1MessageBufferIF& msgBuf, ASN1T_QTNoticeReference& data);
   ASN1C_QTNoticeReference (ASN1C_QTNoticeReference& original);

   ~ASN1C_QTNoticeReference();
   // 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_QTNoticeReference& getCopy (ASN1T_QTNoticeReference* pDstData = 0);
   ASN1T_QTNoticeReference* newCopy ();

   inline ASN1C_QTNoticeReference& operator= (ASN1C_QTNoticeReference& 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_QTNoticeReference (ASN1CTXT* pctxt,
   ASN1T_QTNoticeReference *pvalue, ASN1TagType tagging);

EXTERN int asn1D_QTNoticeReference (ASN1CTXT* pctxt,
   ASN1T_QTNoticeReference *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_QTNoticeReference
  (ASN1CTXT* pctxt, ASN1T_QTNoticeReference* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_QTNoticeReference (ASN1CTXT *pctxt, ASN1T_QTNoticeReference* pSrcValue, ASN1T_QTNoticeReference* pDstValue);

EXTERN void asn1Free_QTNoticeReference (ASN1CTXT *pctxt, ASN1T_QTNoticeReference* pvalue);

/**************************************************************/
/*                                                            */
/*  QTUserNotice                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_QTUserNotice;

typedef struct EXTERN ASN1T_QTUserNotice : public ASN1TPDU {
   struct {
      unsigned noticeRefPresent : 1;
      unsigned explicitTextPresent : 1;
   } m;
   ASN1T_QTNoticeReference noticeRef;
   ASN1T_QTDisplayText explicitText;
   ASN1T_QTUserNotice ();
   ASN1T_QTUserNotice (ASN1C_QTUserNotice& srcData);
   ~ASN1T_QTUserNotice ();
} ASN1T_QTUserNotice;

class EXTERN ASN1C_QTUserNotice :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_QTUserNotice& msgData;
   struct ElementID {
      enum {
         _unknown, noticeRef, explicitText
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_QTNoticeReference* mpNoticeRefC;
   class ASN1C_QTDisplayText* mpExplicitTextC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_QTUserNotice (ASN1T_QTUserNotice& data);
   ASN1C_QTUserNotice (
      ASN1MessageBufferIF& msgBuf, ASN1T_QTUserNotice& data);
   ASN1C_QTUserNotice (ASN1C_QTUserNotice& original);

   ~ASN1C_QTUserNotice();
   // 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_QTUserNotice& getCopy (ASN1T_QTUserNotice* pDstData = 0);
   ASN1T_QTUserNotice* newCopy ();

   inline ASN1C_QTUserNotice& operator= (ASN1C_QTUserNotice& 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_QTUserNotice (ASN1CTXT* pctxt,
   ASN1T_QTUserNotice *pvalue, ASN1TagType tagging);

EXTERN int asn1D_QTUserNotice (ASN1CTXT* pctxt,
   ASN1T_QTUserNotice *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_QTUserNotice
  (ASN1CTXT* pctxt, ASN1T_QTUserNotice* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_QTUserNotice (ASN1CTXT *pctxt, ASN1T_QTUserNotice* pSrcValue, ASN1T_QTUserNotice* pDstValue);

EXTERN void asn1Free_QTUserNotice (ASN1CTXT *pctxt, ASN1T_QTUserNotice* pvalue);

/**************************************************************/
/*                                                            */
/*  PolicyQualifierInfo                                       */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PolicyQualifierInfo;

typedef struct EXTERN ASN1T_PolicyQualifierInfo : public ASN1TPDU {
   struct {
      unsigned qualifierPresent : 1;
   } m;
   ASN1TObjId policyQualifierId;
   Asn1TObject qualifier;
   ASN1T_PolicyQualifierInfo ();
   ASN1T_PolicyQualifierInfo (ASN1C_PolicyQualifierInfo& srcData);
   ~ASN1T_PolicyQualifierInfo ();
} ASN1T_PolicyQualifierInfo;

class EXTERN ASN1C_PolicyQualifierInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyQualifierInfo& msgData;
   struct ElementID {
      enum {
         _unknown, policyQualifierId, qualifier
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1CXerOpenType* mpQualifierC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PolicyQualifierInfo (ASN1T_PolicyQualifierInfo& data);
   ASN1C_PolicyQualifierInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyQualifierInfo& data);
   ASN1C_PolicyQualifierInfo (ASN1C_PolicyQualifierInfo& original);

   ~ASN1C_PolicyQualifierInfo();
   // 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_PolicyQualifierInfo& getCopy (ASN1T_PolicyQualifierInfo* pDstData = 0);
   ASN1T_PolicyQualifierInfo* newCopy ();

   inline ASN1C_PolicyQualifierInfo& operator= (ASN1C_PolicyQualifierInfo& 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_PolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_PolicyQualifierInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_PolicyQualifierInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyQualifierInfo
  (ASN1CTXT* pctxt, ASN1T_PolicyQualifierInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN int asn1XETC_PolicyQualifierInfo (ASN1CTXT* pctxt,
    ASN1T_PolicyQualifierInfo *pvalue);

EXTERN int asn1XDTC_PolicyQualifierInfo (ASN1CtxtPtr& pctxt,
    ASN1T_PolicyQualifierInfo *pvalue);

EXTERN int asn1ETC_PolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_PolicyQualifierInfo *pvalue);

EXTERN int asn1DTC_PolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_PolicyQualifierInfo *pvalue);

EXTERN void asn1Copy_PolicyQualifierInfo (ASN1CTXT *pctxt, ASN1T_PolicyQualifierInfo* pSrcValue, ASN1T_PolicyQualifierInfo* pDstValue);

EXTERN void asn1Free_PolicyQualifierInfo (ASN1CTXT *pctxt, ASN1T_PolicyQualifierInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  PolicyInformation_policyQualifiers                        */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_PolicyInformation_policyQualifiers :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyInformation_policyQualifiers& msgData;
   ASN1T_PolicyQualifierInfo *mpElement;
   class ASN1C_PolicyQualifierInfo* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_PolicyInformation_policyQualifiers (ASN1T_PolicyInformation_policyQualifiers& data);
   ASN1C_PolicyInformation_policyQualifiers (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyInformation_policyQualifiers& data);
   ASN1C_PolicyInformation_policyQualifiers (ASN1C_PolicyInformation_policyQualifiers& original);

   ~ASN1C_PolicyInformation_policyQualifiers();
   // 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_PolicyInformation_policyQualifiers& getCopy (ASN1T_PolicyInformation_policyQualifiers* pDstData = 0);
   ASN1T_PolicyInformation_policyQualifiers* newCopy ();

   ASN1C_PolicyInformation_policyQualifiers& operator= (ASN1C_PolicyInformation_policyQualifiers& srcData);
   void Append (ASN1T_PolicyQualifierInfo * 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_PolicyInformation_policyQualifiers (ASN1CTXT* pctxt,
   ASN1T_PolicyInformation_policyQualifiers *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyInformation_policyQualifiers (ASN1CTXT* pctxt,
   ASN1T_PolicyInformation_policyQualifiers *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyInformation_policyQualifiers
  (ASN1CTXT* pctxt, ASN1T_PolicyInformation_policyQualifiers* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PolicyInformation_policyQualifiers (ASN1CTXT *pctxt, ASN1T_PolicyInformation_policyQualifiers* pSrcValue, ASN1T_PolicyInformation_policyQualifiers* pDstValue);

EXTERN void asn1Free_PolicyInformation_policyQualifiers (ASN1CTXT *pctxt, ASN1T_PolicyInformation_policyQualifiers* pvalue);

/**************************************************************/
/*                                                            */
/*  PolicyInformation                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PolicyInformation;

typedef struct EXTERN ASN1T_PolicyInformation : public ASN1TPDU {
   struct {
      unsigned policyQualifiersPresent : 1;
   } m;
   ASN1T_CertPolicyId policyIdentifier;
   ASN1T_PolicyInformation_policyQualifiers policyQualifiers;
   ASN1T_PolicyInformation ();
   ASN1T_PolicyInformation (ASN1C_PolicyInformation& srcData);
   ~ASN1T_PolicyInformation ();
} ASN1T_PolicyInformation;

class EXTERN ASN1C_PolicyInformation :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyInformation& msgData;
   struct ElementID {
      enum {
         _unknown, policyIdentifier, policyQualifiers
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PolicyInformation_policyQualifiers* mpPolicyQualifiersC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PolicyInformation (ASN1T_PolicyInformation& data);
   ASN1C_PolicyInformation (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyInformation& data);
   ASN1C_PolicyInformation (ASN1C_PolicyInformation& original);

   ~ASN1C_PolicyInformation();
   // 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_PolicyInformation& getCopy (ASN1T_PolicyInformation* pDstData = 0);
   ASN1T_PolicyInformation* newCopy ();

   inline ASN1C_PolicyInformation& operator= (ASN1C_PolicyInformation& 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_PolicyInformation (ASN1CTXT* pctxt,
   ASN1T_PolicyInformation *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyInformation (ASN1CTXT* pctxt,
   ASN1T_PolicyInformation *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyInformation
  (ASN1CTXT* pctxt, ASN1T_PolicyInformation* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PolicyInformation (ASN1CTXT *pctxt, ASN1T_PolicyInformation* pSrcValue, ASN1T_PolicyInformation* pDstValue);

EXTERN void asn1Free_PolicyInformation (ASN1CTXT *pctxt, ASN1T_PolicyInformation* pvalue);

/**************************************************************/
/*                                                            */
/*  AuthorityKeyIdentifier                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_AuthorityKeyIdentifier;

typedef struct EXTERN ASN1T_AuthorityKeyIdentifier : public ASN1TPDU {
   struct {
      unsigned keyIdentifierPresent : 1;
      unsigned authorityCertIssuerPresent : 1;
      unsigned authorityCertSerialNumberPresent : 1;
   } m;
   ASN1T_KeyIdentifier keyIdentifier;
   ASN1TSeqOfList authorityCertIssuer;
   ASN1ConstCharPtr authorityCertSerialNumber;
   ASN1T_AuthorityKeyIdentifier ();
   ASN1T_AuthorityKeyIdentifier (ASN1C_AuthorityKeyIdentifier& srcData);
   ~ASN1T_AuthorityKeyIdentifier ();
} ASN1T_AuthorityKeyIdentifier;

class EXTERN ASN1C_AuthorityKeyIdentifier :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AuthorityKeyIdentifier& msgData;
   struct ElementID {
      enum {
         _unknown, keyIdentifier, authorityCertIssuer,
         authorityCertSerialNumber
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralNames* mpAuthorityCertIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_AuthorityKeyIdentifier (ASN1T_AuthorityKeyIdentifier& data);
   ASN1C_AuthorityKeyIdentifier (
      ASN1MessageBufferIF& msgBuf, ASN1T_AuthorityKeyIdentifier& data);
   ASN1C_AuthorityKeyIdentifier (ASN1C_AuthorityKeyIdentifier& original);

   ~ASN1C_AuthorityKeyIdentifier();
   // 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_AuthorityKeyIdentifier& getCopy (ASN1T_AuthorityKeyIdentifier* pDstData = 0);
   ASN1T_AuthorityKeyIdentifier* newCopy ();

   inline ASN1C_AuthorityKeyIdentifier& operator= (ASN1C_AuthorityKeyIdentifier& 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_AuthorityKeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_AuthorityKeyIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AuthorityKeyIdentifier (ASN1CTXT* pctxt,
   ASN1T_AuthorityKeyIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AuthorityKeyIdentifier
  (ASN1CTXT* pctxt, ASN1T_AuthorityKeyIdentifier* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AuthorityKeyIdentifier (ASN1CTXT *pctxt, ASN1T_AuthorityKeyIdentifier* pSrcValue, ASN1T_AuthorityKeyIdentifier* pDstValue);

EXTERN void asn1Free_AuthorityKeyIdentifier (ASN1CTXT *pctxt, ASN1T_AuthorityKeyIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  _extKeyUsage_ExtnType                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C__extKeyUsage_ExtnType;

typedef struct EXTERN ASN1T__extKeyUsage_ExtnType : public ASN1TPDU {
   ASN1UINT n;
   ASN1T_KeyPurposeId *elem;
   ASN1T__extKeyUsage_ExtnType () : n (0), elem(NULL) {} // FIXED for PVS
   ASN1T__extKeyUsage_ExtnType (ASN1C__extKeyUsage_ExtnType& srcData);
   ~ASN1T__extKeyUsage_ExtnType ();
} ASN1T__extKeyUsage_ExtnType;

class EXTERN ASN1C__extKeyUsage_ExtnType :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T__extKeyUsage_ExtnType& msgData;
   Asn1RTDList tmpList;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C__extKeyUsage_ExtnType (ASN1T__extKeyUsage_ExtnType& data);
   ASN1C__extKeyUsage_ExtnType (
      ASN1MessageBufferIF& msgBuf, ASN1T__extKeyUsage_ExtnType& data);
   ASN1C__extKeyUsage_ExtnType (ASN1C__extKeyUsage_ExtnType& 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__extKeyUsage_ExtnType& getCopy (ASN1T__extKeyUsage_ExtnType* pDstData = 0);
   ASN1T__extKeyUsage_ExtnType* newCopy ();

   ASN1C__extKeyUsage_ExtnType& operator= (ASN1C__extKeyUsage_ExtnType& 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__extKeyUsage_ExtnType (ASN1CTXT* pctxt,
   ASN1T__extKeyUsage_ExtnType *pvalue, ASN1TagType tagging);

EXTERN int asn1D__extKeyUsage_ExtnType (ASN1CTXT* pctxt,
   ASN1T__extKeyUsage_ExtnType *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE__extKeyUsage_ExtnType
  (ASN1CTXT* pctxt, ASN1T__extKeyUsage_ExtnType* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy__extKeyUsage_ExtnType (ASN1CTXT *pctxt, ASN1T__extKeyUsage_ExtnType* pSrcValue, ASN1T__extKeyUsage_ExtnType* pDstValue);

EXTERN void asn1Free__extKeyUsage_ExtnType (ASN1CTXT *pctxt, ASN1T__extKeyUsage_ExtnType* pvalue);

/**************************************************************/
/*                                                            */
/*  PrivateKeyUsagePeriod                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PrivateKeyUsagePeriod;

typedef struct EXTERN ASN1T_PrivateKeyUsagePeriod : public ASN1TPDU {
   struct {
      unsigned notBeforePresent : 1;
      unsigned notAfterPresent : 1;
   } m;
   ASN1GeneralizedTime notBefore;
   ASN1GeneralizedTime notAfter;
   ASN1T_PrivateKeyUsagePeriod ();
   ASN1T_PrivateKeyUsagePeriod (ASN1C_PrivateKeyUsagePeriod& srcData);
   ~ASN1T_PrivateKeyUsagePeriod ();
} ASN1T_PrivateKeyUsagePeriod;

class EXTERN ASN1C_PrivateKeyUsagePeriod :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PrivateKeyUsagePeriod& msgData;
   struct ElementID {
      enum {
         _unknown, notBefore, notAfter
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PrivateKeyUsagePeriod (ASN1T_PrivateKeyUsagePeriod& data);
   ASN1C_PrivateKeyUsagePeriod (
      ASN1MessageBufferIF& msgBuf, ASN1T_PrivateKeyUsagePeriod& data);
   ASN1C_PrivateKeyUsagePeriod (ASN1C_PrivateKeyUsagePeriod& 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_PrivateKeyUsagePeriod& getCopy (ASN1T_PrivateKeyUsagePeriod* pDstData = 0);
   ASN1T_PrivateKeyUsagePeriod* newCopy ();

   inline ASN1C_PrivateKeyUsagePeriod& operator= (ASN1C_PrivateKeyUsagePeriod& 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_PrivateKeyUsagePeriod (ASN1CTXT* pctxt,
   ASN1T_PrivateKeyUsagePeriod *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PrivateKeyUsagePeriod (ASN1CTXT* pctxt,
   ASN1T_PrivateKeyUsagePeriod *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PrivateKeyUsagePeriod
  (ASN1CTXT* pctxt, ASN1T_PrivateKeyUsagePeriod* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PrivateKeyUsagePeriod (ASN1CTXT *pctxt, ASN1T_PrivateKeyUsagePeriod* pSrcValue, ASN1T_PrivateKeyUsagePeriod* pDstValue);

EXTERN void asn1Free_PrivateKeyUsagePeriod (ASN1CTXT *pctxt, ASN1T_PrivateKeyUsagePeriod* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificatePoliciesSyntax                                 */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_CertificatePoliciesSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificatePoliciesSyntax& msgData;
   ASN1T_PolicyInformation *mpElement;
   class ASN1C_PolicyInformation* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_CertificatePoliciesSyntax (ASN1T_CertificatePoliciesSyntax& data);
   ASN1C_CertificatePoliciesSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificatePoliciesSyntax& data);
   ASN1C_CertificatePoliciesSyntax (ASN1C_CertificatePoliciesSyntax& original);

   ~ASN1C_CertificatePoliciesSyntax();
   // 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_CertificatePoliciesSyntax& getCopy (ASN1T_CertificatePoliciesSyntax* pDstData = 0);
   ASN1T_CertificatePoliciesSyntax* newCopy ();

   ASN1C_CertificatePoliciesSyntax& operator= (ASN1C_CertificatePoliciesSyntax& srcData);
   void Append (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_CertificatePoliciesSyntax (ASN1CTXT* pctxt,
   ASN1T_CertificatePoliciesSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificatePoliciesSyntax (ASN1CTXT* pctxt,
   ASN1T_CertificatePoliciesSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificatePoliciesSyntax
  (ASN1CTXT* pctxt, ASN1T_CertificatePoliciesSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificatePoliciesSyntax (ASN1CTXT *pctxt, ASN1T_CertificatePoliciesSyntax* pSrcValue, ASN1T_CertificatePoliciesSyntax* pDstValue);

EXTERN void asn1Free_CertificatePoliciesSyntax (ASN1CTXT *pctxt, ASN1T_CertificatePoliciesSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  PolicyMappingsSyntax_element                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PolicyMappingsSyntax_element;

typedef struct EXTERN ASN1T_PolicyMappingsSyntax_element : public ASN1TPDU {
   ASN1T_CertPolicyId issuerDomainPolicy;
   ASN1T_CertPolicyId subjectDomainPolicy;
   ASN1T_PolicyMappingsSyntax_element ();
   ASN1T_PolicyMappingsSyntax_element (ASN1C_PolicyMappingsSyntax_element& srcData);
} ASN1T_PolicyMappingsSyntax_element;

class EXTERN ASN1C_PolicyMappingsSyntax_element :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyMappingsSyntax_element& msgData;
   struct ElementID {
      enum {
         _unknown, issuerDomainPolicy, subjectDomainPolicy
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PolicyMappingsSyntax_element (ASN1T_PolicyMappingsSyntax_element& data);
   ASN1C_PolicyMappingsSyntax_element (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyMappingsSyntax_element& data);
   ASN1C_PolicyMappingsSyntax_element (ASN1C_PolicyMappingsSyntax_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_PolicyMappingsSyntax_element& getCopy (ASN1T_PolicyMappingsSyntax_element* pDstData = 0);
   ASN1T_PolicyMappingsSyntax_element* newCopy ();

   inline ASN1C_PolicyMappingsSyntax_element& operator= (ASN1C_PolicyMappingsSyntax_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_PolicyMappingsSyntax_element (ASN1CTXT* pctxt,
   ASN1T_PolicyMappingsSyntax_element *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyMappingsSyntax_element (ASN1CTXT* pctxt,
   ASN1T_PolicyMappingsSyntax_element *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyMappingsSyntax_element
  (ASN1CTXT* pctxt, ASN1T_PolicyMappingsSyntax_element* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PolicyMappingsSyntax_element (ASN1CTXT *pctxt, ASN1T_PolicyMappingsSyntax_element* pSrcValue, ASN1T_PolicyMappingsSyntax_element* pDstValue);

/**************************************************************/
/*                                                            */
/*  PolicyMappingsSyntax                                      */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_PolicyMappingsSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyMappingsSyntax& msgData;
   ASN1T_PolicyMappingsSyntax_element *mpElement;
   class ASN1C_PolicyMappingsSyntax_element* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_PolicyMappingsSyntax (ASN1T_PolicyMappingsSyntax& data);
   ASN1C_PolicyMappingsSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyMappingsSyntax& data);
   ASN1C_PolicyMappingsSyntax (ASN1C_PolicyMappingsSyntax& original);

   ~ASN1C_PolicyMappingsSyntax();
   // 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_PolicyMappingsSyntax& getCopy (ASN1T_PolicyMappingsSyntax* pDstData = 0);
   ASN1T_PolicyMappingsSyntax* newCopy ();

   ASN1C_PolicyMappingsSyntax& operator= (ASN1C_PolicyMappingsSyntax& srcData);
   void Append (ASN1T_PolicyMappingsSyntax_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_PolicyMappingsSyntax (ASN1CTXT* pctxt,
   ASN1T_PolicyMappingsSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyMappingsSyntax (ASN1CTXT* pctxt,
   ASN1T_PolicyMappingsSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyMappingsSyntax
  (ASN1CTXT* pctxt, ASN1T_PolicyMappingsSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PolicyMappingsSyntax (ASN1CTXT *pctxt, ASN1T_PolicyMappingsSyntax* pSrcValue, ASN1T_PolicyMappingsSyntax* pDstValue);

EXTERN void asn1Free_PolicyMappingsSyntax (ASN1CTXT *pctxt, ASN1T_PolicyMappingsSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  AttributesSyntax                                          */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_AttributesSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AttributesSyntax& msgData;
   struct ASN1T_Attribute *mpElement;
   class ASN1C_Attribute* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_AttributesSyntax (ASN1T_AttributesSyntax& data);
   ASN1C_AttributesSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_AttributesSyntax& data);
   ASN1C_AttributesSyntax (ASN1C_AttributesSyntax& original);

   ~ASN1C_AttributesSyntax();
   // 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_AttributesSyntax& getCopy (ASN1T_AttributesSyntax* pDstData = 0);
   ASN1T_AttributesSyntax* newCopy ();

   ASN1C_AttributesSyntax& operator= (ASN1C_AttributesSyntax& srcData);
   void Append (struct ASN1T_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_AttributesSyntax (ASN1CTXT* pctxt,
   ASN1T_AttributesSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AttributesSyntax (ASN1CTXT* pctxt,
   ASN1T_AttributesSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AttributesSyntax
  (ASN1CTXT* pctxt, ASN1T_AttributesSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AttributesSyntax (ASN1CTXT *pctxt, ASN1T_AttributesSyntax* pSrcValue, ASN1T_AttributesSyntax* pDstValue);

EXTERN void asn1Free_AttributesSyntax (ASN1CTXT *pctxt, ASN1T_AttributesSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  BasicConstraintsSyntax                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_BasicConstraintsSyntax;

typedef struct EXTERN ASN1T_BasicConstraintsSyntax : public ASN1TPDU {
   struct {
      unsigned pathLenConstraintPresent : 1;
   } m;
   ASN1BOOL cA;
   ASN1UINT pathLenConstraint;
   ASN1T_BasicConstraintsSyntax ();
   ASN1T_BasicConstraintsSyntax (ASN1C_BasicConstraintsSyntax& srcData);
} ASN1T_BasicConstraintsSyntax;

class EXTERN ASN1C_BasicConstraintsSyntax :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_BasicConstraintsSyntax& msgData;
   struct ElementID {
      enum {
         _unknown, cA, pathLenConstraint
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_BasicConstraintsSyntax (ASN1T_BasicConstraintsSyntax& data);
   ASN1C_BasicConstraintsSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_BasicConstraintsSyntax& data);
   ASN1C_BasicConstraintsSyntax (ASN1C_BasicConstraintsSyntax& 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_BasicConstraintsSyntax& getCopy (ASN1T_BasicConstraintsSyntax* pDstData = 0);
   ASN1T_BasicConstraintsSyntax* newCopy ();

   inline ASN1C_BasicConstraintsSyntax& operator= (ASN1C_BasicConstraintsSyntax& 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_BasicConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_BasicConstraintsSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BasicConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_BasicConstraintsSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BasicConstraintsSyntax
  (ASN1CTXT* pctxt, ASN1T_BasicConstraintsSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BasicConstraintsSyntax (ASN1CTXT *pctxt, ASN1T_BasicConstraintsSyntax* pSrcValue, ASN1T_BasicConstraintsSyntax* pDstValue);

/**************************************************************/
/*                                                            */
/*  GeneralSubtree                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_GeneralSubtree;

typedef struct EXTERN ASN1T_GeneralSubtree : public ASN1TPDU {
   struct {
      unsigned maximumPresent : 1;
   } m;
   struct ASN1T_GeneralName *base;
   ASN1T_BaseDistance minimum;
   ASN1T_BaseDistance maximum;
   ASN1T_GeneralSubtree ();
   ASN1T_GeneralSubtree (ASN1C_GeneralSubtree& srcData);
   ~ASN1T_GeneralSubtree ();
} ASN1T_GeneralSubtree;

class EXTERN ASN1C_GeneralSubtree :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_GeneralSubtree& msgData;
   struct ElementID {
      enum {
         _unknown, base, minimum, maximum
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralName* mpBaseC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_GeneralSubtree (ASN1T_GeneralSubtree& data);
   ASN1C_GeneralSubtree (
      ASN1MessageBufferIF& msgBuf, ASN1T_GeneralSubtree& data);
   ASN1C_GeneralSubtree (ASN1C_GeneralSubtree& original);

   ~ASN1C_GeneralSubtree();
   // 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_GeneralSubtree& getCopy (ASN1T_GeneralSubtree* pDstData = 0);
   ASN1T_GeneralSubtree* newCopy ();

   inline ASN1C_GeneralSubtree& operator= (ASN1C_GeneralSubtree& 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_GeneralSubtree (ASN1CTXT* pctxt,
   ASN1T_GeneralSubtree *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GeneralSubtree (ASN1CTXT* pctxt,
   ASN1T_GeneralSubtree *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_GeneralSubtree
  (ASN1CTXT* pctxt, ASN1T_GeneralSubtree* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_GeneralSubtree (ASN1CTXT *pctxt, ASN1T_GeneralSubtree* pSrcValue, ASN1T_GeneralSubtree* pDstValue);

EXTERN void asn1Free_GeneralSubtree (ASN1CTXT *pctxt, ASN1T_GeneralSubtree* pvalue);

/**************************************************************/
/*                                                            */
/*  GeneralSubtrees                                           */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_GeneralSubtrees :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_GeneralSubtrees& msgData;
   ASN1T_GeneralSubtree *mpElement;
   class ASN1C_GeneralSubtree* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_GeneralSubtrees (ASN1T_GeneralSubtrees& data);
   ASN1C_GeneralSubtrees (
      ASN1MessageBufferIF& msgBuf, ASN1T_GeneralSubtrees& data);
   ASN1C_GeneralSubtrees (ASN1C_GeneralSubtrees& original);

   ~ASN1C_GeneralSubtrees();
   // 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_GeneralSubtrees& getCopy (ASN1T_GeneralSubtrees* pDstData = 0);
   ASN1T_GeneralSubtrees* newCopy ();

   ASN1C_GeneralSubtrees& operator= (ASN1C_GeneralSubtrees& srcData);
   void Append (ASN1T_GeneralSubtree * 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_GeneralSubtrees (ASN1CTXT* pctxt,
   ASN1T_GeneralSubtrees *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GeneralSubtrees (ASN1CTXT* pctxt,
   ASN1T_GeneralSubtrees *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_GeneralSubtrees
  (ASN1CTXT* pctxt, ASN1T_GeneralSubtrees* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_GeneralSubtrees (ASN1CTXT *pctxt, ASN1T_GeneralSubtrees* pSrcValue, ASN1T_GeneralSubtrees* pDstValue);

EXTERN void asn1Free_GeneralSubtrees (ASN1CTXT *pctxt, ASN1T_GeneralSubtrees* pvalue);

/**************************************************************/
/*                                                            */
/*  NameForms_otherNameForms                                  */
/*                                                            */
/**************************************************************/

#define TV_NameForms_otherNameForms	(TM_CTXT|TM_CONS|1)

class EXTERN ASN1C_NameForms_otherNameForms;

typedef struct EXTERN ASN1T_NameForms_otherNameForms : public ASN1TPDU {
   ASN1UINT n;
   ASN1TObjId *elem;
   ASN1T_NameForms_otherNameForms () : n (0), elem(NULL) {} // FIXED for PVS
   ASN1T_NameForms_otherNameForms (ASN1C_NameForms_otherNameForms& srcData);
   ~ASN1T_NameForms_otherNameForms ();
} ASN1T_NameForms_otherNameForms;

class EXTERN ASN1C_NameForms_otherNameForms :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_NameForms_otherNameForms& msgData;
   Asn1RTDList tmpList;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_NameForms_otherNameForms (ASN1T_NameForms_otherNameForms& data);
   ASN1C_NameForms_otherNameForms (
      ASN1MessageBufferIF& msgBuf, ASN1T_NameForms_otherNameForms& data);
   ASN1C_NameForms_otherNameForms (ASN1C_NameForms_otherNameForms& 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_NameForms_otherNameForms& getCopy (ASN1T_NameForms_otherNameForms* pDstData = 0);
   ASN1T_NameForms_otherNameForms* newCopy ();

   ASN1C_NameForms_otherNameForms& operator= (ASN1C_NameForms_otherNameForms& 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_NameForms_otherNameForms (ASN1CTXT* pctxt,
   ASN1T_NameForms_otherNameForms *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NameForms_otherNameForms (ASN1CTXT* pctxt,
   ASN1T_NameForms_otherNameForms *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_NameForms_otherNameForms
  (ASN1CTXT* pctxt, ASN1T_NameForms_otherNameForms* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_NameForms_otherNameForms (ASN1CTXT *pctxt, ASN1T_NameForms_otherNameForms* pSrcValue, ASN1T_NameForms_otherNameForms* pDstValue);

EXTERN void asn1Free_NameForms_otherNameForms (ASN1CTXT *pctxt, ASN1T_NameForms_otherNameForms* pvalue);

/**************************************************************/
/*                                                            */
/*  NameForms                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_NameForms;

typedef struct EXTERN ASN1T_NameForms : public ASN1TPDU {
   struct {
      unsigned basicNameFormsPresent : 1;
      unsigned otherNameFormsPresent : 1;
   } m;
   ASN1T_BasicNameForms basicNameForms;
   ASN1T_NameForms_otherNameForms otherNameForms;
   ASN1T_NameForms ();
   ASN1T_NameForms (ASN1C_NameForms& srcData);
   ~ASN1T_NameForms ();
} ASN1T_NameForms;

class EXTERN ASN1C_NameForms :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_NameForms& msgData;
   struct ElementID {
      enum {
         _unknown, basicNameForms, otherNameForms
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_NameForms_otherNameForms* mpOtherNameFormsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_NameForms (ASN1T_NameForms& data);
   ASN1C_NameForms (
      ASN1MessageBufferIF& msgBuf, ASN1T_NameForms& data);
   ASN1C_NameForms (ASN1C_NameForms& original);

   ~ASN1C_NameForms();
   // 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_NameForms& getCopy (ASN1T_NameForms* pDstData = 0);
   ASN1T_NameForms* newCopy ();

   inline ASN1C_NameForms& operator= (ASN1C_NameForms& 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_NameForms (ASN1CTXT* pctxt,
   ASN1T_NameForms *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NameForms (ASN1CTXT* pctxt,
   ASN1T_NameForms *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_NameForms
  (ASN1CTXT* pctxt, ASN1T_NameForms* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_NameForms (ASN1CTXT *pctxt, ASN1T_NameForms* pSrcValue, ASN1T_NameForms* pDstValue);

EXTERN void asn1Free_NameForms (ASN1CTXT *pctxt, ASN1T_NameForms* pvalue);

/**************************************************************/
/*                                                            */
/*  NameConstraintsSyntax                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_NameConstraintsSyntax;

typedef struct EXTERN ASN1T_NameConstraintsSyntax : public ASN1TPDU {
   struct {
      unsigned permittedSubtreesPresent : 1;
      unsigned excludedSubtreesPresent : 1;
      unsigned requiredNameFormsPresent : 1;
   } m;
   ASN1T_GeneralSubtrees permittedSubtrees;
   ASN1T_GeneralSubtrees excludedSubtrees;
   ASN1T_NameForms requiredNameForms;
   ASN1T_NameConstraintsSyntax ();
   ASN1T_NameConstraintsSyntax (ASN1C_NameConstraintsSyntax& srcData);
   ~ASN1T_NameConstraintsSyntax ();
} ASN1T_NameConstraintsSyntax;

class EXTERN ASN1C_NameConstraintsSyntax :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_NameConstraintsSyntax& msgData;
   struct ElementID {
      enum {
         _unknown, permittedSubtrees, excludedSubtrees, requiredNameForms
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralSubtrees* mpPermittedSubtreesC;
   class ASN1C_GeneralSubtrees* mpExcludedSubtreesC;
   class ASN1C_NameForms* mpRequiredNameFormsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_NameConstraintsSyntax (ASN1T_NameConstraintsSyntax& data);
   ASN1C_NameConstraintsSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_NameConstraintsSyntax& data);
   ASN1C_NameConstraintsSyntax (ASN1C_NameConstraintsSyntax& original);

   ~ASN1C_NameConstraintsSyntax();
   // 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_NameConstraintsSyntax& getCopy (ASN1T_NameConstraintsSyntax* pDstData = 0);
   ASN1T_NameConstraintsSyntax* newCopy ();

   inline ASN1C_NameConstraintsSyntax& operator= (ASN1C_NameConstraintsSyntax& 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_NameConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_NameConstraintsSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NameConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_NameConstraintsSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_NameConstraintsSyntax
  (ASN1CTXT* pctxt, ASN1T_NameConstraintsSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_NameConstraintsSyntax (ASN1CTXT *pctxt, ASN1T_NameConstraintsSyntax* pSrcValue, ASN1T_NameConstraintsSyntax* pDstValue);

EXTERN void asn1Free_NameConstraintsSyntax (ASN1CTXT *pctxt, ASN1T_NameConstraintsSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  PolicyConstraintsSyntax                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PolicyConstraintsSyntax;

typedef struct EXTERN ASN1T_PolicyConstraintsSyntax : public ASN1TPDU {
   struct {
      unsigned requireExplicitPolicyPresent : 1;
      unsigned inhibitPolicyMappingPresent : 1;
   } m;
   ASN1T_SkipCerts requireExplicitPolicy;
   ASN1T_SkipCerts inhibitPolicyMapping;
   ASN1T_PolicyConstraintsSyntax ();
   ASN1T_PolicyConstraintsSyntax (ASN1C_PolicyConstraintsSyntax& srcData);
} ASN1T_PolicyConstraintsSyntax;

class EXTERN ASN1C_PolicyConstraintsSyntax :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PolicyConstraintsSyntax& msgData;
   struct ElementID {
      enum {
         _unknown, requireExplicitPolicy, inhibitPolicyMapping
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PolicyConstraintsSyntax (ASN1T_PolicyConstraintsSyntax& data);
   ASN1C_PolicyConstraintsSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_PolicyConstraintsSyntax& data);
   ASN1C_PolicyConstraintsSyntax (ASN1C_PolicyConstraintsSyntax& 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_PolicyConstraintsSyntax& getCopy (ASN1T_PolicyConstraintsSyntax* pDstData = 0);
   ASN1T_PolicyConstraintsSyntax* newCopy ();

   inline ASN1C_PolicyConstraintsSyntax& operator= (ASN1C_PolicyConstraintsSyntax& 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_PolicyConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_PolicyConstraintsSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PolicyConstraintsSyntax (ASN1CTXT* pctxt,
   ASN1T_PolicyConstraintsSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PolicyConstraintsSyntax
  (ASN1CTXT* pctxt, ASN1T_PolicyConstraintsSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PolicyConstraintsSyntax (ASN1CTXT *pctxt, ASN1T_PolicyConstraintsSyntax* pSrcValue, ASN1T_PolicyConstraintsSyntax* pDstValue);

/**************************************************************/
/*                                                            */
/*  DistributionPointName                                     */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_DistributionPointName_fullName 1
#define T_DistributionPointName_nameRelativeToCRLIssuer 2

class EXTERN ASN1C_DistributionPointName;

typedef struct EXTERN ASN1T_DistributionPointName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1TSeqOfList *fullName;
      /* t = 2 */
      ASN1TSeqOfList *nameRelativeToCRLIssuer;
   } u;
   ASN1T_DistributionPointName () {}
   ASN1T_DistributionPointName (ASN1C_DistributionPointName& srcData);
   ~ASN1T_DistributionPointName ();
} ASN1T_DistributionPointName;

class EXTERN ASN1C_DistributionPointName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DistributionPointName& msgData;
   struct ElementID {
      enum {
         _unknown, fullName, nameRelativeToCRLIssuer
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralNames* mpFullNameC;
   class ASN1C_RelativeDistinguishedName* mpNameRelativeToCRLIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_DistributionPointName (ASN1T_DistributionPointName& data);
   ASN1C_DistributionPointName (
      ASN1MessageBufferIF& msgBuf, ASN1T_DistributionPointName& data);
   ASN1C_DistributionPointName (ASN1C_DistributionPointName& original);

   ~ASN1C_DistributionPointName();
   // 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_DistributionPointName& getCopy (ASN1T_DistributionPointName* pDstData = 0);
   ASN1T_DistributionPointName* newCopy ();

   inline ASN1C_DistributionPointName& operator= (ASN1C_DistributionPointName& 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_DistributionPointName (ASN1CTXT* pctxt,
   ASN1T_DistributionPointName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DistributionPointName (ASN1CTXT* pctxt,
   ASN1T_DistributionPointName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DistributionPointName
  (ASN1CTXT* pctxt, ASN1T_DistributionPointName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DistributionPointName (ASN1CTXT *pctxt, ASN1T_DistributionPointName* pSrcValue, ASN1T_DistributionPointName* pDstValue);

EXTERN void asn1Free_DistributionPointName (ASN1CTXT *pctxt, ASN1T_DistributionPointName* pvalue);

/**************************************************************/
/*                                                            */
/*  DistributionPoint                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DistributionPoint;

typedef struct EXTERN ASN1T_DistributionPoint : public ASN1TPDU {
   struct {
      unsigned distributionPointPresent : 1;
      unsigned reasonsPresent : 1;
      unsigned cRLIssuerPresent : 1;
   } m;
   ASN1T_DistributionPointName distributionPoint;
   ASN1T_ReasonFlags reasons;
   ASN1TSeqOfList cRLIssuer;
   ASN1T_DistributionPoint ();
   ASN1T_DistributionPoint (ASN1C_DistributionPoint& srcData);
   ~ASN1T_DistributionPoint ();
} ASN1T_DistributionPoint;

class EXTERN ASN1C_DistributionPoint :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DistributionPoint& msgData;
   struct ElementID {
      enum {
         _unknown, distributionPoint, reasons, cRLIssuer
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DistributionPointName* mpDistributionPointC;
   class ASN1C_GeneralNames* mpCRLIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_DistributionPoint (ASN1T_DistributionPoint& data);
   ASN1C_DistributionPoint (
      ASN1MessageBufferIF& msgBuf, ASN1T_DistributionPoint& data);
   ASN1C_DistributionPoint (ASN1C_DistributionPoint& original);

   ~ASN1C_DistributionPoint();
   // 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_DistributionPoint& getCopy (ASN1T_DistributionPoint* pDstData = 0);
   ASN1T_DistributionPoint* newCopy ();

   inline ASN1C_DistributionPoint& operator= (ASN1C_DistributionPoint& 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_DistributionPoint (ASN1CTXT* pctxt,
   ASN1T_DistributionPoint *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DistributionPoint (ASN1CTXT* pctxt,
   ASN1T_DistributionPoint *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DistributionPoint
  (ASN1CTXT* pctxt, ASN1T_DistributionPoint* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DistributionPoint (ASN1CTXT *pctxt, ASN1T_DistributionPoint* pSrcValue, ASN1T_DistributionPoint* pDstValue);

EXTERN void asn1Free_DistributionPoint (ASN1CTXT *pctxt, ASN1T_DistributionPoint* pvalue);

/**************************************************************/
/*                                                            */
/*  CRLDistPointsSyntax                                       */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_CRLDistPointsSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CRLDistPointsSyntax& msgData;
   ASN1T_DistributionPoint *mpElement;
   class ASN1C_DistributionPoint* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_CRLDistPointsSyntax (ASN1T_CRLDistPointsSyntax& data);
   ASN1C_CRLDistPointsSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_CRLDistPointsSyntax& data);
   ASN1C_CRLDistPointsSyntax (ASN1C_CRLDistPointsSyntax& original);

   ~ASN1C_CRLDistPointsSyntax();
   // 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_CRLDistPointsSyntax& getCopy (ASN1T_CRLDistPointsSyntax* pDstData = 0);
   ASN1T_CRLDistPointsSyntax* newCopy ();

   ASN1C_CRLDistPointsSyntax& operator= (ASN1C_CRLDistPointsSyntax& srcData);
   void Append (ASN1T_DistributionPoint * 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_CRLDistPointsSyntax (ASN1CTXT* pctxt,
   ASN1T_CRLDistPointsSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRLDistPointsSyntax (ASN1CTXT* pctxt,
   ASN1T_CRLDistPointsSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CRLDistPointsSyntax
  (ASN1CTXT* pctxt, ASN1T_CRLDistPointsSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CRLDistPointsSyntax (ASN1CTXT *pctxt, ASN1T_CRLDistPointsSyntax* pSrcValue, ASN1T_CRLDistPointsSyntax* pDstValue);

EXTERN void asn1Free_CRLDistPointsSyntax (ASN1CTXT *pctxt, ASN1T_CRLDistPointsSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  IssuingDistPointSyntax                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_IssuingDistPointSyntax;

typedef struct EXTERN ASN1T_IssuingDistPointSyntax : public ASN1TPDU {
   struct {
      unsigned distributionPointPresent : 1;
      unsigned onlySomeReasonsPresent : 1;
   } m;
   ASN1T_DistributionPointName distributionPoint;
   ASN1BOOL onlyContainsUserCerts;
   ASN1BOOL onlyContainsCACerts;
   ASN1T_ReasonFlags onlySomeReasons;
   ASN1BOOL indirectCRL;
   ASN1T_IssuingDistPointSyntax ();
   ASN1T_IssuingDistPointSyntax (ASN1C_IssuingDistPointSyntax& srcData);
   ~ASN1T_IssuingDistPointSyntax ();
} ASN1T_IssuingDistPointSyntax;

class EXTERN ASN1C_IssuingDistPointSyntax :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_IssuingDistPointSyntax& msgData;
   struct ElementID {
      enum {
         _unknown, distributionPoint, onlyContainsUserCerts,
         onlyContainsCACerts, onlySomeReasons, indirectCRL
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DistributionPointName* mpDistributionPointC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_IssuingDistPointSyntax (ASN1T_IssuingDistPointSyntax& data);
   ASN1C_IssuingDistPointSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_IssuingDistPointSyntax& data);
   ASN1C_IssuingDistPointSyntax (ASN1C_IssuingDistPointSyntax& original);

   ~ASN1C_IssuingDistPointSyntax();
   // 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_IssuingDistPointSyntax& getCopy (ASN1T_IssuingDistPointSyntax* pDstData = 0);
   ASN1T_IssuingDistPointSyntax* newCopy ();

   inline ASN1C_IssuingDistPointSyntax& operator= (ASN1C_IssuingDistPointSyntax& 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_IssuingDistPointSyntax (ASN1CTXT* pctxt,
   ASN1T_IssuingDistPointSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_IssuingDistPointSyntax (ASN1CTXT* pctxt,
   ASN1T_IssuingDistPointSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_IssuingDistPointSyntax
  (ASN1CTXT* pctxt, ASN1T_IssuingDistPointSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_IssuingDistPointSyntax (ASN1CTXT *pctxt, ASN1T_IssuingDistPointSyntax* pSrcValue, ASN1T_IssuingDistPointSyntax* pDstValue);

EXTERN void asn1Free_IssuingDistPointSyntax (ASN1CTXT *pctxt, ASN1T_IssuingDistPointSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  BaseCRLNumber                                             */
/*                                                            */
/**************************************************************/

typedef ASN1T_CRLNumber ASN1T_BaseCRLNumber;

class EXTERN ASN1C_BaseCRLNumber :
   public ASN1C_CRLNumber
{
protected:
public:
   ASN1C_BaseCRLNumber (ASN1T_BaseCRLNumber& data);
   ASN1C_BaseCRLNumber (
      ASN1MessageBufferIF& msgBuf, ASN1T_BaseCRLNumber& data);
   ASN1C_BaseCRLNumber (ASN1C_BaseCRLNumber& 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_BaseCRLNumber& getCopy (ASN1T_BaseCRLNumber* pDstData = 0);
   ASN1T_BaseCRLNumber* newCopy ();

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

EXTERN int asn1E_BaseCRLNumber (ASN1CTXT* pctxt,
   ASN1T_BaseCRLNumber *pvalue, ASN1TagType tagging);

EXTERN int asn1D_BaseCRLNumber (ASN1CTXT* pctxt,
   ASN1T_BaseCRLNumber *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_BaseCRLNumber
  (ASN1CTXT* pctxt, ASN1T_BaseCRLNumber value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_BaseCRLNumber (ASN1CTXT *pctxt, ASN1T_BaseCRLNumber* pSrcValue, ASN1T_BaseCRLNumber* pDstValue);

/**************************************************************/
/*                                                            */
/*  FreshestCRL                                               */
/*                                                            */
/**************************************************************/

typedef ASN1T_CRLDistPointsSyntax ASN1T_FreshestCRL;

class EXTERN ASN1C_FreshestCRL :
   public ASN1C_CRLDistPointsSyntax
{
protected:
public:
   ASN1C_FreshestCRL (ASN1T_FreshestCRL& data);
   ASN1C_FreshestCRL (
      ASN1MessageBufferIF& msgBuf, ASN1T_FreshestCRL& data);
   ASN1C_FreshestCRL (ASN1C_FreshestCRL& 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_FreshestCRL& getCopy (ASN1T_FreshestCRL* pDstData = 0);
   ASN1T_FreshestCRL* newCopy ();

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

EXTERN int asn1E_FreshestCRL (ASN1CTXT* pctxt,
   ASN1T_FreshestCRL *pvalue, ASN1TagType tagging);

EXTERN int asn1D_FreshestCRL (ASN1CTXT* pctxt,
   ASN1T_FreshestCRL *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_FreshestCRL
  (ASN1CTXT* pctxt, ASN1T_FreshestCRL* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_FreshestCRL (ASN1CTXT *pctxt, ASN1T_FreshestCRL* pSrcValue, ASN1T_FreshestCRL* pDstValue);

EXTERN void asn1Free_FreshestCRL (ASN1CTXT *pctxt, ASN1T_FreshestCRL* pvalue);

/**************************************************************/
/*                                                            */
/*  AccessDescription                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_AccessDescription;

typedef struct EXTERN ASN1T_AccessDescription : public ASN1TPDU {
   ASN1TObjId accessMethod;
   struct ASN1T_GeneralName *accessLocation;
   ASN1T_AccessDescription ();
   ASN1T_AccessDescription (ASN1C_AccessDescription& srcData);
   ~ASN1T_AccessDescription ();
} ASN1T_AccessDescription;

class EXTERN ASN1C_AccessDescription :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AccessDescription& msgData;
   struct ElementID {
      enum {
         _unknown, accessMethod, accessLocation
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralName* mpAccessLocationC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_AccessDescription (ASN1T_AccessDescription& data);
   ASN1C_AccessDescription (
      ASN1MessageBufferIF& msgBuf, ASN1T_AccessDescription& data);
   ASN1C_AccessDescription (ASN1C_AccessDescription& original);

   ~ASN1C_AccessDescription();
   // 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_AccessDescription& getCopy (ASN1T_AccessDescription* pDstData = 0);
   ASN1T_AccessDescription* newCopy ();

   inline ASN1C_AccessDescription& operator= (ASN1C_AccessDescription& 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_AccessDescription (ASN1CTXT* pctxt,
   ASN1T_AccessDescription *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AccessDescription (ASN1CTXT* pctxt,
   ASN1T_AccessDescription *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AccessDescription
  (ASN1CTXT* pctxt, ASN1T_AccessDescription* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AccessDescription (ASN1CTXT *pctxt, ASN1T_AccessDescription* pSrcValue, ASN1T_AccessDescription* pDstValue);

EXTERN void asn1Free_AccessDescription (ASN1CTXT *pctxt, ASN1T_AccessDescription* pvalue);

/**************************************************************/
/*                                                            */
/*  AuthorityInfoAccessSyntax                                 */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_AuthorityInfoAccessSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AuthorityInfoAccessSyntax& msgData;
   ASN1T_AccessDescription *mpElement;
   class ASN1C_AccessDescription* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_AuthorityInfoAccessSyntax (ASN1T_AuthorityInfoAccessSyntax& data);
   ASN1C_AuthorityInfoAccessSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_AuthorityInfoAccessSyntax& data);
   ASN1C_AuthorityInfoAccessSyntax (ASN1C_AuthorityInfoAccessSyntax& original);

   ~ASN1C_AuthorityInfoAccessSyntax();
   // 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_AuthorityInfoAccessSyntax& getCopy (ASN1T_AuthorityInfoAccessSyntax* pDstData = 0);
   ASN1T_AuthorityInfoAccessSyntax* newCopy ();

   ASN1C_AuthorityInfoAccessSyntax& operator= (ASN1C_AuthorityInfoAccessSyntax& srcData);
   void Append (ASN1T_AccessDescription * 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_AuthorityInfoAccessSyntax (ASN1CTXT* pctxt,
   ASN1T_AuthorityInfoAccessSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AuthorityInfoAccessSyntax (ASN1CTXT* pctxt,
   ASN1T_AuthorityInfoAccessSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AuthorityInfoAccessSyntax
  (ASN1CTXT* pctxt, ASN1T_AuthorityInfoAccessSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AuthorityInfoAccessSyntax (ASN1CTXT *pctxt, ASN1T_AuthorityInfoAccessSyntax* pSrcValue, ASN1T_AuthorityInfoAccessSyntax* pDstValue);

EXTERN void asn1Free_AuthorityInfoAccessSyntax (ASN1CTXT *pctxt, ASN1T_AuthorityInfoAccessSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  SubjectInfoAccessSyntax                                   */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_SubjectInfoAccessSyntax :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SubjectInfoAccessSyntax& msgData;
   ASN1T_AccessDescription *mpElement;
   class ASN1C_AccessDescription* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_SubjectInfoAccessSyntax (ASN1T_SubjectInfoAccessSyntax& data);
   ASN1C_SubjectInfoAccessSyntax (
      ASN1MessageBufferIF& msgBuf, ASN1T_SubjectInfoAccessSyntax& data);
   ASN1C_SubjectInfoAccessSyntax (ASN1C_SubjectInfoAccessSyntax& original);

   ~ASN1C_SubjectInfoAccessSyntax();
   // 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_SubjectInfoAccessSyntax& getCopy (ASN1T_SubjectInfoAccessSyntax* pDstData = 0);
   ASN1T_SubjectInfoAccessSyntax* newCopy ();

   ASN1C_SubjectInfoAccessSyntax& operator= (ASN1C_SubjectInfoAccessSyntax& srcData);
   void Append (ASN1T_AccessDescription * 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_SubjectInfoAccessSyntax (ASN1CTXT* pctxt,
   ASN1T_SubjectInfoAccessSyntax *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SubjectInfoAccessSyntax (ASN1CTXT* pctxt,
   ASN1T_SubjectInfoAccessSyntax *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SubjectInfoAccessSyntax
  (ASN1CTXT* pctxt, ASN1T_SubjectInfoAccessSyntax* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SubjectInfoAccessSyntax (ASN1CTXT *pctxt, ASN1T_SubjectInfoAccessSyntax* pSrcValue, ASN1T_SubjectInfoAccessSyntax* pDstValue);

EXTERN void asn1Free_SubjectInfoAccessSyntax (ASN1CTXT *pctxt, ASN1T_SubjectInfoAccessSyntax* pvalue);

/**************************************************************/
/*                                                            */
/*  EDIPartyName_nameAssigner                                 */
/*                                                            */
/**************************************************************/

#define TV_EDIPartyName_nameAssigner	(TM_CTXT|TM_CONS|0)

/* Choice tag constants */

#define T_EDIPartyName_nameAssigner_utf8String 1
#define T_EDIPartyName_nameAssigner_printableString 2
#define T_EDIPartyName_nameAssigner_teletexString 3
#define T_EDIPartyName_nameAssigner_universalString 4
#define T_EDIPartyName_nameAssigner_bmpString 5

class EXTERN ASN1C_EDIPartyName_nameAssigner;

typedef struct EXTERN ASN1T_EDIPartyName_nameAssigner : 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_EDIPartyName_nameAssigner () {}
   ASN1T_EDIPartyName_nameAssigner (ASN1C_EDIPartyName_nameAssigner& srcData);
   ~ASN1T_EDIPartyName_nameAssigner ();
} ASN1T_EDIPartyName_nameAssigner;

class EXTERN ASN1C_EDIPartyName_nameAssigner :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EDIPartyName_nameAssigner& 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_EDIPartyName_nameAssigner (ASN1T_EDIPartyName_nameAssigner& data);
   ASN1C_EDIPartyName_nameAssigner (
      ASN1MessageBufferIF& msgBuf, ASN1T_EDIPartyName_nameAssigner& data);
   ASN1C_EDIPartyName_nameAssigner (ASN1C_EDIPartyName_nameAssigner& 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_EDIPartyName_nameAssigner& getCopy (ASN1T_EDIPartyName_nameAssigner* pDstData = 0);
   ASN1T_EDIPartyName_nameAssigner* newCopy ();

   inline ASN1C_EDIPartyName_nameAssigner& operator= (ASN1C_EDIPartyName_nameAssigner& 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_EDIPartyName_nameAssigner (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName_nameAssigner *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EDIPartyName_nameAssigner (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName_nameAssigner *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EDIPartyName_nameAssigner
  (ASN1CTXT* pctxt, ASN1T_EDIPartyName_nameAssigner* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EDIPartyName_nameAssigner (ASN1CTXT *pctxt, ASN1T_EDIPartyName_nameAssigner* pSrcValue, ASN1T_EDIPartyName_nameAssigner* pDstValue);

EXTERN void asn1Free_EDIPartyName_nameAssigner (ASN1CTXT *pctxt, ASN1T_EDIPartyName_nameAssigner* pvalue);

/**************************************************************/
/*                                                            */
/*  EDIPartyName_partyName                                    */
/*                                                            */
/**************************************************************/

#define TV_EDIPartyName_partyName	(TM_CTXT|TM_CONS|1)

/* Choice tag constants */

#define T_EDIPartyName_partyName_utf8String 1
#define T_EDIPartyName_partyName_printableString 2
#define T_EDIPartyName_partyName_teletexString 3
#define T_EDIPartyName_partyName_universalString 4
#define T_EDIPartyName_partyName_bmpString 5

class EXTERN ASN1C_EDIPartyName_partyName;

typedef struct EXTERN ASN1T_EDIPartyName_partyName : 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_EDIPartyName_partyName () {}
   ASN1T_EDIPartyName_partyName (ASN1C_EDIPartyName_partyName& srcData);
   ~ASN1T_EDIPartyName_partyName ();
} ASN1T_EDIPartyName_partyName;

class EXTERN ASN1C_EDIPartyName_partyName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EDIPartyName_partyName& 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_EDIPartyName_partyName (ASN1T_EDIPartyName_partyName& data);
   ASN1C_EDIPartyName_partyName (
      ASN1MessageBufferIF& msgBuf, ASN1T_EDIPartyName_partyName& data);
   ASN1C_EDIPartyName_partyName (ASN1C_EDIPartyName_partyName& 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_EDIPartyName_partyName& getCopy (ASN1T_EDIPartyName_partyName* pDstData = 0);
   ASN1T_EDIPartyName_partyName* newCopy ();

   inline ASN1C_EDIPartyName_partyName& operator= (ASN1C_EDIPartyName_partyName& 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_EDIPartyName_partyName (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName_partyName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EDIPartyName_partyName (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName_partyName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EDIPartyName_partyName
  (ASN1CTXT* pctxt, ASN1T_EDIPartyName_partyName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EDIPartyName_partyName (ASN1CTXT *pctxt, ASN1T_EDIPartyName_partyName* pSrcValue, ASN1T_EDIPartyName_partyName* pDstValue);

EXTERN void asn1Free_EDIPartyName_partyName (ASN1CTXT *pctxt, ASN1T_EDIPartyName_partyName* pvalue);

/**************************************************************/
/*                                                            */
/*  EDIPartyName                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_EDIPartyName;

typedef struct EXTERN ASN1T_EDIPartyName : public ASN1TPDU {
   struct {
      unsigned nameAssignerPresent : 1;
   } m;
   ASN1T_EDIPartyName_nameAssigner nameAssigner;
   ASN1T_EDIPartyName_partyName partyName;
   ASN1T_EDIPartyName ();
   ASN1T_EDIPartyName (ASN1C_EDIPartyName& srcData);
   ~ASN1T_EDIPartyName ();
} ASN1T_EDIPartyName;

class EXTERN ASN1C_EDIPartyName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EDIPartyName& msgData;
   struct ElementID {
      enum {
         _unknown, nameAssigner, partyName
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_EDIPartyName_nameAssigner* mpNameAssignerC;
   class ASN1C_EDIPartyName_partyName* mpPartyNameC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_EDIPartyName (ASN1T_EDIPartyName& data);
   ASN1C_EDIPartyName (
      ASN1MessageBufferIF& msgBuf, ASN1T_EDIPartyName& data);
   ASN1C_EDIPartyName (ASN1C_EDIPartyName& original);

   ~ASN1C_EDIPartyName();
   // 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_EDIPartyName& getCopy (ASN1T_EDIPartyName* pDstData = 0);
   ASN1T_EDIPartyName* newCopy ();

   inline ASN1C_EDIPartyName& operator= (ASN1C_EDIPartyName& 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_EDIPartyName (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EDIPartyName (ASN1CTXT* pctxt,
   ASN1T_EDIPartyName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EDIPartyName
  (ASN1CTXT* pctxt, ASN1T_EDIPartyName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EDIPartyName (ASN1CTXT *pctxt, ASN1T_EDIPartyName* pSrcValue, ASN1T_EDIPartyName* pDstValue);

EXTERN void asn1Free_EDIPartyName (ASN1CTXT *pctxt, ASN1T_EDIPartyName* pvalue);

/**************************************************************/
/*                                                            */
/*  GeneralName                                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_GeneralName_otherName         1
#define T_GeneralName_rfc822Name        2
#define T_GeneralName_dNSName           3
#define T_GeneralName_x400Address       4
#define T_GeneralName_directoryName     5
#define T_GeneralName_ediPartyName      6
#define T_GeneralName_uniformResourceIdentifier 7
#define T_GeneralName_iPAddress         8
#define T_GeneralName_registeredID      9

class EXTERN ASN1C_GeneralName;

typedef struct EXTERN ASN1T_GeneralName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_GeneralName_otherName *otherName;
      /* t = 2 */
      ASN1IA5String rfc822Name;
      /* t = 3 */
      ASN1IA5String dNSName;
      /* t = 4 */
      struct ASN1T_ORAddress *x400Address;
      /* t = 5 */
      struct ASN1T_Name *directoryName;
      /* t = 6 */
      ASN1T_EDIPartyName *ediPartyName;
      /* t = 7 */
      ASN1IA5String uniformResourceIdentifier;
      /* t = 8 */
      ASN1TDynOctStr *iPAddress;
      /* t = 9 */
      ASN1TObjId *registeredID;
   } u;
   ASN1T_GeneralName () {}
   ASN1T_GeneralName (ASN1C_GeneralName& srcData);
   ~ASN1T_GeneralName ();
} ASN1T_GeneralName;

class EXTERN ASN1C_GeneralName :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_GeneralName& msgData;
   struct ElementID {
      enum {
         _unknown, otherName, rfc822Name, dNSName, x400Address, directoryName,
         ediPartyName, uniformResourceIdentifier, iPAddress, registeredID
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralName_otherName* mpOtherNameC;
   class ASN1C_ORAddress* mpX400AddressC;
   class ASN1C_Name* mpDirectoryNameC;
   class ASN1C_EDIPartyName* mpEdiPartyNameC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_GeneralName (ASN1T_GeneralName& data);
   ASN1C_GeneralName (
      ASN1MessageBufferIF& msgBuf, ASN1T_GeneralName& data);
   ASN1C_GeneralName (ASN1C_GeneralName& original);

   ~ASN1C_GeneralName();
   // 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_GeneralName& getCopy (ASN1T_GeneralName* pDstData = 0);
   ASN1T_GeneralName* newCopy ();

   inline ASN1C_GeneralName& operator= (ASN1C_GeneralName& 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_GeneralName (ASN1CTXT* pctxt,
   ASN1T_GeneralName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GeneralName (ASN1CTXT* pctxt,
   ASN1T_GeneralName *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_GeneralName
  (ASN1CTXT* pctxt, ASN1T_GeneralName* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_GeneralName (ASN1CTXT *pctxt, ASN1T_GeneralName* pSrcValue, ASN1T_GeneralName* pDstValue);

EXTERN void asn1Free_GeneralName (ASN1CTXT *pctxt, ASN1T_GeneralName* pvalue);

/**************************************************************/
/*                                                            */
/*  GeneralNames                                              */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_GeneralNames :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_GeneralNames& msgData;
   ASN1T_GeneralName *mpElement;
   class ASN1C_GeneralName* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_GeneralNames (ASN1T_GeneralNames& data);
   ASN1C_GeneralNames (
      ASN1MessageBufferIF& msgBuf, ASN1T_GeneralNames& data);
   ASN1C_GeneralNames (ASN1C_GeneralNames& original);

   ~ASN1C_GeneralNames();
   // 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_GeneralNames& getCopy (ASN1T_GeneralNames* pDstData = 0);
   ASN1T_GeneralNames* newCopy ();

   ASN1C_GeneralNames& operator= (ASN1C_GeneralNames& srcData);
   void Append (ASN1T_GeneralName * 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_GeneralNames (ASN1CTXT* pctxt,
   ASN1T_GeneralNames *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GeneralNames (ASN1CTXT* pctxt,
   ASN1T_GeneralNames *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_GeneralNames
  (ASN1CTXT* pctxt, ASN1T_GeneralNames* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_GeneralNames (ASN1CTXT *pctxt, ASN1T_GeneralNames* pSrcValue, ASN1T_GeneralNames* pDstValue);

EXTERN void asn1Free_GeneralNames (ASN1CTXT *pctxt, ASN1T_GeneralNames* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateIssuer                                         */
/*                                                            */
/**************************************************************/

typedef ASN1T_GeneralNames ASN1T_CertificateIssuer;

class EXTERN ASN1C_CertificateIssuer :
   public ASN1C_GeneralNames
{
protected:
public:
   ASN1C_CertificateIssuer (ASN1T_CertificateIssuer& data);
   ASN1C_CertificateIssuer (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateIssuer& data);
   ASN1C_CertificateIssuer (ASN1C_CertificateIssuer& 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_CertificateIssuer& getCopy (ASN1T_CertificateIssuer* pDstData = 0);
   ASN1T_CertificateIssuer* newCopy ();

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

EXTERN int asn1E_CertificateIssuer (ASN1CTXT* pctxt,
   ASN1T_CertificateIssuer *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateIssuer (ASN1CTXT* pctxt,
   ASN1T_CertificateIssuer *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateIssuer
  (ASN1CTXT* pctxt, ASN1T_CertificateIssuer* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateIssuer (ASN1CTXT *pctxt, ASN1T_CertificateIssuer* pSrcValue, ASN1T_CertificateIssuer* pDstValue);

EXTERN void asn1Free_CertificateIssuer (ASN1CTXT *pctxt, ASN1T_CertificateIssuer* pvalue);

/**************************************************************/
/*                                                            */
/*  AltNameType_builtinNameForm                               */
/*                                                            */
/**************************************************************/

struct EXTERN AltNameType_builtinNameForm {
   enum Root {
      rfc822Name = 1,
      dNSName = 2,
      x400Address = 3,
      directoryName = 4,
      ediPartyName = 5,
      uniformResourceIdentifier = 6,
      iPAddress = 7,
      registeredId = 8
   } ;
} ;

typedef ASN1UINT ASN1T_AltNameType_builtinNameForm;

class EXTERN ASN1C_AltNameType_builtinNameForm :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AltNameType_builtinNameForm& msgData;
public:
   ASN1C_AltNameType_builtinNameForm (ASN1T_AltNameType_builtinNameForm& data);
   ASN1C_AltNameType_builtinNameForm (
      ASN1MessageBufferIF& msgBuf, ASN1T_AltNameType_builtinNameForm& data);
   ASN1C_AltNameType_builtinNameForm (ASN1C_AltNameType_builtinNameForm& 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_AltNameType_builtinNameForm& getCopy (ASN1T_AltNameType_builtinNameForm* pDstData = 0);
   ASN1T_AltNameType_builtinNameForm* newCopy ();

   inline ASN1C_AltNameType_builtinNameForm& operator= (ASN1C_AltNameType_builtinNameForm& srcData) {
      srcData.getCopy (&msgData);
      return *this;
   }
   static int parseNamedValue (ASN1CTXT* pctxt, ASN1UINT* value);
} ;

EXTERN int asn1E_AltNameType_builtinNameForm (ASN1CTXT* pctxt,
   ASN1T_AltNameType_builtinNameForm *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AltNameType_builtinNameForm (ASN1CTXT* pctxt,
   ASN1T_AltNameType_builtinNameForm *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AltNameType_builtinNameForm
  (ASN1CTXT* pctxt, ASN1T_AltNameType_builtinNameForm value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AltNameType_builtinNameForm (ASN1CTXT *pctxt, ASN1T_AltNameType_builtinNameForm* pSrcValue, ASN1T_AltNameType_builtinNameForm* pDstValue);

/**************************************************************/
/*                                                            */
/*  SupportedAlgorithm                                        */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SupportedAlgorithm;

typedef struct EXTERN ASN1T_SupportedAlgorithm : public ASN1TPDU {
   struct {
      unsigned intendedUsagePresent : 1;
      unsigned intendedCertificatePoliciesPresent : 1;
   } m;
   struct ASN1T_AlgorithmIdentifier *algorithmIdentifier;
   ASN1T_KeyUsage intendedUsage;
   ASN1T_CertificatePoliciesSyntax intendedCertificatePolicies;
   ASN1T_SupportedAlgorithm ();
   ASN1T_SupportedAlgorithm (ASN1C_SupportedAlgorithm& srcData);
   ~ASN1T_SupportedAlgorithm ();
} ASN1T_SupportedAlgorithm;

class EXTERN ASN1C_SupportedAlgorithm :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SupportedAlgorithm& msgData;
   struct ElementID {
      enum {
         _unknown, algorithmIdentifier, intendedUsage,
         intendedCertificatePolicies
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpAlgorithmIdentifierC;
   class ASN1C_CertificatePoliciesSyntax* mpIntendedCertificatePoliciesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_SupportedAlgorithm (ASN1T_SupportedAlgorithm& data);
   ASN1C_SupportedAlgorithm (
      ASN1MessageBufferIF& msgBuf, ASN1T_SupportedAlgorithm& data);
   ASN1C_SupportedAlgorithm (ASN1C_SupportedAlgorithm& original);

   ~ASN1C_SupportedAlgorithm();
   // 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_SupportedAlgorithm& getCopy (ASN1T_SupportedAlgorithm* pDstData = 0);
   ASN1T_SupportedAlgorithm* newCopy ();

   inline ASN1C_SupportedAlgorithm& operator= (ASN1C_SupportedAlgorithm& 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_SupportedAlgorithm (ASN1CTXT* pctxt,
   ASN1T_SupportedAlgorithm *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SupportedAlgorithm (ASN1CTXT* pctxt,
   ASN1T_SupportedAlgorithm *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SupportedAlgorithm
  (ASN1CTXT* pctxt, ASN1T_SupportedAlgorithm* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SupportedAlgorithm (ASN1CTXT *pctxt, ASN1T_SupportedAlgorithm* pSrcValue, ASN1T_SupportedAlgorithm* pDstValue);

EXTERN void asn1Free_SupportedAlgorithm (ASN1CTXT *pctxt, ASN1T_SupportedAlgorithm* pvalue);

/**************************************************************/
/*                                                            */
/*  CertPolicySet                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertPolicySet;

typedef struct EXTERN ASN1T_CertPolicySet : public ASN1TPDU {
   ASN1UINT n;
   ASN1T_CertPolicyId *elem;
   ASN1T_CertPolicySet () : n (0), elem(NULL) {} // FIXED for PVS
   ASN1T_CertPolicySet (ASN1C_CertPolicySet& srcData);
   ~ASN1T_CertPolicySet ();
} ASN1T_CertPolicySet;

class EXTERN ASN1C_CertPolicySet :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertPolicySet& msgData;
   Asn1RTDList tmpList;
   ASN1MemBuf mCurrElemValue;

public:
   ASN1C_CertPolicySet (ASN1T_CertPolicySet& data);
   ASN1C_CertPolicySet (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertPolicySet& data);
   ASN1C_CertPolicySet (ASN1C_CertPolicySet& 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_CertPolicySet& getCopy (ASN1T_CertPolicySet* pDstData = 0);
   ASN1T_CertPolicySet* newCopy ();

   ASN1C_CertPolicySet& operator= (ASN1C_CertPolicySet& 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_CertPolicySet (ASN1CTXT* pctxt,
   ASN1T_CertPolicySet *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertPolicySet (ASN1CTXT* pctxt,
   ASN1T_CertPolicySet *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertPolicySet
  (ASN1CTXT* pctxt, ASN1T_CertPolicySet* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertPolicySet (ASN1CTXT *pctxt, ASN1T_CertPolicySet* pSrcValue, ASN1T_CertPolicySet* pDstValue);

EXTERN void asn1Free_CertPolicySet (ASN1CTXT *pctxt, ASN1T_CertPolicySet* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateExactAssertion                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificateExactAssertion;

typedef struct EXTERN ASN1T_CertificateExactAssertion : public ASN1TPDU {
   ASN1ConstCharPtr serialNumber;
   struct ASN1T_Name *issuer;
   ASN1T_CertificateExactAssertion ();
   ASN1T_CertificateExactAssertion (ASN1C_CertificateExactAssertion& srcData);
   ~ASN1T_CertificateExactAssertion ();
} ASN1T_CertificateExactAssertion;

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

   class ASN1C_Name* mpIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertificateExactAssertion (ASN1T_CertificateExactAssertion& data);
   ASN1C_CertificateExactAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateExactAssertion& data);
   ASN1C_CertificateExactAssertion (ASN1C_CertificateExactAssertion& original);

   ~ASN1C_CertificateExactAssertion();
   // 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_CertificateExactAssertion& getCopy (ASN1T_CertificateExactAssertion* pDstData = 0);
   ASN1T_CertificateExactAssertion* newCopy ();

   inline ASN1C_CertificateExactAssertion& operator= (ASN1C_CertificateExactAssertion& 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_CertificateExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateExactAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateExactAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateExactAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificateExactAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificateExactAssertion* pSrcValue, ASN1T_CertificateExactAssertion* pDstValue);

EXTERN void asn1Free_CertificateExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificateExactAssertion* pvalue);

/**************************************************************/
/*                                                            */
/*  AltNameType                                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_AltNameType_otherNameForm     1
#define T_AltNameType_builtinNameForm   2

class EXTERN ASN1C_AltNameType;

typedef struct EXTERN ASN1T_AltNameType : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1TObjId *otherNameForm;
      /* t = 2 */
      ASN1T_AltNameType_builtinNameForm builtinNameForm;
   } u;
   ASN1T_AltNameType () {}
   ASN1T_AltNameType (ASN1C_AltNameType& srcData);
   ~ASN1T_AltNameType ();
} ASN1T_AltNameType;

class EXTERN ASN1C_AltNameType :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_AltNameType& msgData;
   struct ElementID {
      enum {
         _unknown, otherNameForm, builtinNameForm
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_AltNameType (ASN1T_AltNameType& data);
   ASN1C_AltNameType (
      ASN1MessageBufferIF& msgBuf, ASN1T_AltNameType& data);
   ASN1C_AltNameType (ASN1C_AltNameType& 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_AltNameType& getCopy (ASN1T_AltNameType* pDstData = 0);
   ASN1T_AltNameType* newCopy ();

   inline ASN1C_AltNameType& operator= (ASN1C_AltNameType& 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_AltNameType (ASN1CTXT* pctxt,
   ASN1T_AltNameType *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AltNameType (ASN1CTXT* pctxt,
   ASN1T_AltNameType *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_AltNameType
  (ASN1CTXT* pctxt, ASN1T_AltNameType* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_AltNameType (ASN1CTXT *pctxt, ASN1T_AltNameType* pSrcValue, ASN1T_AltNameType* pDstValue);

EXTERN void asn1Free_AltNameType (ASN1CTXT *pctxt, ASN1T_AltNameType* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateAssertion                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificateAssertion;

typedef struct EXTERN ASN1T_CertificateAssertion : public ASN1TPDU {
   struct {
      unsigned serialNumberPresent : 1;
      unsigned issuerPresent : 1;
      unsigned subjectKeyIdentifierPresent : 1;
      unsigned authorityKeyIdentifierPresent : 1;
      unsigned certificateValidPresent : 1;
      unsigned privateKeyValidPresent : 1;
      unsigned subjectPublicKeyAlgIDPresent : 1;
      unsigned keyUsagePresent : 1;
      unsigned subjectAltNamePresent : 1;
      unsigned policyPresent : 1;
      unsigned pathToNamePresent : 1;
   } m;
   ASN1ConstCharPtr serialNumber;
   struct ASN1T_Name *issuer;
   ASN1T_SubjectKeyIdentifier subjectKeyIdentifier;
   ASN1T_AuthorityKeyIdentifier authorityKeyIdentifier;
   struct ASN1T_Time *certificateValid;
   ASN1GeneralizedTime privateKeyValid;
   ASN1TObjId subjectPublicKeyAlgID;
   ASN1T_KeyUsage keyUsage;
   ASN1T_AltNameType subjectAltName;
   ASN1T_CertPolicySet policy;
   struct ASN1T_Name *pathToName;
   ASN1T_CertificateAssertion ();
   ASN1T_CertificateAssertion (ASN1C_CertificateAssertion& srcData);
   ~ASN1T_CertificateAssertion ();
} ASN1T_CertificateAssertion;

class EXTERN ASN1C_CertificateAssertion :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificateAssertion& msgData;
   struct ElementID {
      enum {
         _unknown, serialNumber, issuer, subjectKeyIdentifier,
         authorityKeyIdentifier, certificateValid, privateKeyValid,
         subjectPublicKeyAlgID, keyUsage, subjectAltName, policy, pathToName
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Name* mpIssuerC;
   class ASN1C_AuthorityKeyIdentifier* mpAuthorityKeyIdentifierC;
   class ASN1C_Time* mpCertificateValidC;
   class ASN1C_AltNameType* mpSubjectAltNameC;
   class ASN1C_CertPolicySet* mpPolicyC;
   class ASN1C_Name* mpPathToNameC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertificateAssertion (ASN1T_CertificateAssertion& data);
   ASN1C_CertificateAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateAssertion& data);
   ASN1C_CertificateAssertion (ASN1C_CertificateAssertion& original);

   ~ASN1C_CertificateAssertion();
   // 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_CertificateAssertion& getCopy (ASN1T_CertificateAssertion* pDstData = 0);
   ASN1T_CertificateAssertion* newCopy ();

   inline ASN1C_CertificateAssertion& operator= (ASN1C_CertificateAssertion& 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_CertificateAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificateAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateAssertion (ASN1CTXT *pctxt, ASN1T_CertificateAssertion* pSrcValue, ASN1T_CertificateAssertion* pDstValue);

EXTERN void asn1Free_CertificateAssertion (ASN1CTXT *pctxt, ASN1T_CertificateAssertion* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificatePairExactAssertion                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificatePairExactAssertion;

typedef struct EXTERN ASN1T_CertificatePairExactAssertion : public ASN1TPDU {
   struct {
      unsigned forwardAssertionPresent : 1;
      unsigned reverseAssertionPresent : 1;
   } m;
   ASN1T_CertificateExactAssertion forwardAssertion;
   ASN1T_CertificateExactAssertion reverseAssertion;
   ASN1T_CertificatePairExactAssertion ();
   ASN1T_CertificatePairExactAssertion (ASN1C_CertificatePairExactAssertion& srcData);
   ~ASN1T_CertificatePairExactAssertion ();
} ASN1T_CertificatePairExactAssertion;

class EXTERN ASN1C_CertificatePairExactAssertion :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificatePairExactAssertion& msgData;
   struct ElementID {
      enum {
         _unknown, forwardAssertion, reverseAssertion
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CertificateExactAssertion* mpForwardAssertionC;
   class ASN1C_CertificateExactAssertion* mpReverseAssertionC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_CertificatePairExactAssertion (ASN1T_CertificatePairExactAssertion& data);
   ASN1C_CertificatePairExactAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificatePairExactAssertion& data);
   ASN1C_CertificatePairExactAssertion (ASN1C_CertificatePairExactAssertion& original);

   ~ASN1C_CertificatePairExactAssertion();
   // 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_CertificatePairExactAssertion& getCopy (ASN1T_CertificatePairExactAssertion* pDstData = 0);
   ASN1T_CertificatePairExactAssertion* newCopy ();

   inline ASN1C_CertificatePairExactAssertion& operator= (ASN1C_CertificatePairExactAssertion& 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_CertificatePairExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificatePairExactAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificatePairExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificatePairExactAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificatePairExactAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificatePairExactAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificatePairExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificatePairExactAssertion* pSrcValue, ASN1T_CertificatePairExactAssertion* pDstValue);

EXTERN void asn1Free_CertificatePairExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificatePairExactAssertion* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificatePairAssertion                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificatePairAssertion;

typedef struct EXTERN ASN1T_CertificatePairAssertion : public ASN1TPDU {
   struct {
      unsigned forwardAssertionPresent : 1;
      unsigned reverseAssertionPresent : 1;
   } m;
   ASN1T_CertificateAssertion forwardAssertion;
   ASN1T_CertificateAssertion reverseAssertion;
   ASN1T_CertificatePairAssertion ();
   ASN1T_CertificatePairAssertion (ASN1C_CertificatePairAssertion& srcData);
   ~ASN1T_CertificatePairAssertion ();
} ASN1T_CertificatePairAssertion;

class EXTERN ASN1C_CertificatePairAssertion :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificatePairAssertion& msgData;
   struct ElementID {
      enum {
         _unknown, forwardAssertion, reverseAssertion
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CertificateAssertion* mpForwardAssertionC;
   class ASN1C_CertificateAssertion* mpReverseAssertionC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_CertificatePairAssertion (ASN1T_CertificatePairAssertion& data);
   ASN1C_CertificatePairAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificatePairAssertion& data);
   ASN1C_CertificatePairAssertion (ASN1C_CertificatePairAssertion& original);

   ~ASN1C_CertificatePairAssertion();
   // 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_CertificatePairAssertion& getCopy (ASN1T_CertificatePairAssertion* pDstData = 0);
   ASN1T_CertificatePairAssertion* newCopy ();

   inline ASN1C_CertificatePairAssertion& operator= (ASN1C_CertificatePairAssertion& 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_CertificatePairAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificatePairAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificatePairAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificatePairAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificatePairAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificatePairAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificatePairAssertion (ASN1CTXT *pctxt, ASN1T_CertificatePairAssertion* pSrcValue, ASN1T_CertificatePairAssertion* pDstValue);

EXTERN void asn1Free_CertificatePairAssertion (ASN1CTXT *pctxt, ASN1T_CertificatePairAssertion* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateListExactAssertion                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificateListExactAssertion;

typedef struct EXTERN ASN1T_CertificateListExactAssertion : public ASN1TPDU {
   struct {
      unsigned distributionPointPresent : 1;
   } m;
   struct ASN1T_Name *issuer;
   struct ASN1T_Time *thisUpdate;
   ASN1T_DistributionPointName distributionPoint;
   ASN1T_CertificateListExactAssertion ();
   ASN1T_CertificateListExactAssertion (ASN1C_CertificateListExactAssertion& srcData);
   ~ASN1T_CertificateListExactAssertion ();
} ASN1T_CertificateListExactAssertion;

class EXTERN ASN1C_CertificateListExactAssertion :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificateListExactAssertion& msgData;
   struct ElementID {
      enum {
         _unknown, issuer, thisUpdate, distributionPoint
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Name* mpIssuerC;
   class ASN1C_Time* mpThisUpdateC;
   class ASN1C_DistributionPointName* mpDistributionPointC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_CertificateListExactAssertion (ASN1T_CertificateListExactAssertion& data);
   ASN1C_CertificateListExactAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateListExactAssertion& data);
   ASN1C_CertificateListExactAssertion (ASN1C_CertificateListExactAssertion& original);

   ~ASN1C_CertificateListExactAssertion();
   // 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_CertificateListExactAssertion& getCopy (ASN1T_CertificateListExactAssertion* pDstData = 0);
   ASN1T_CertificateListExactAssertion* newCopy ();

   inline ASN1C_CertificateListExactAssertion& operator= (ASN1C_CertificateListExactAssertion& 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_CertificateListExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateListExactAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateListExactAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateListExactAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateListExactAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificateListExactAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateListExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificateListExactAssertion* pSrcValue, ASN1T_CertificateListExactAssertion* pDstValue);

EXTERN void asn1Free_CertificateListExactAssertion (ASN1CTXT *pctxt, ASN1T_CertificateListExactAssertion* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateListAssertion                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificateListAssertion;

typedef struct EXTERN ASN1T_CertificateListAssertion : public ASN1TPDU {
   struct {
      unsigned issuerPresent : 1;
      unsigned minCRLNumberPresent : 1;
      unsigned maxCRLNumberPresent : 1;
      unsigned reasonFlagsPresent : 1;
      unsigned dateAndTimePresent : 1;
      unsigned distributionPointPresent : 1;
   } m;
   struct ASN1T_Name *issuer;
   ASN1T_CRLNumber minCRLNumber;
   ASN1T_CRLNumber maxCRLNumber;
   ASN1T_ReasonFlags reasonFlags;
   struct ASN1T_Time *dateAndTime;
   ASN1T_DistributionPointName distributionPoint;
   ASN1T_CertificateListAssertion ();
   ASN1T_CertificateListAssertion (ASN1C_CertificateListAssertion& srcData);
   ~ASN1T_CertificateListAssertion ();
} ASN1T_CertificateListAssertion;

class EXTERN ASN1C_CertificateListAssertion :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertificateListAssertion& msgData;
   struct ElementID {
      enum {
         _unknown, issuer, minCRLNumber, maxCRLNumber, reasonFlags,
         dateAndTime, distributionPoint
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Name* mpIssuerC;
   class ASN1C_Time* mpDateAndTimeC;
   class ASN1C_DistributionPointName* mpDistributionPointC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertificateListAssertion (ASN1T_CertificateListAssertion& data);
   ASN1C_CertificateListAssertion (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertificateListAssertion& data);
   ASN1C_CertificateListAssertion (ASN1C_CertificateListAssertion& original);

   ~ASN1C_CertificateListAssertion();
   // 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_CertificateListAssertion& getCopy (ASN1T_CertificateListAssertion* pDstData = 0);
   ASN1T_CertificateListAssertion* newCopy ();

   inline ASN1C_CertificateListAssertion& operator= (ASN1C_CertificateListAssertion& 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_CertificateListAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateListAssertion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateListAssertion (ASN1CTXT* pctxt,
   ASN1T_CertificateListAssertion *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertificateListAssertion
  (ASN1CTXT* pctxt, ASN1T_CertificateListAssertion* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertificateListAssertion (ASN1CTXT *pctxt, ASN1T_CertificateListAssertion* pSrcValue, ASN1T_CertificateListAssertion* pDstValue);

EXTERN void asn1Free_CertificateListAssertion (ASN1CTXT *pctxt, ASN1T_CertificateListAssertion* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_pe_authorityInfoAccess;
extern EXTERN ASN1OBJID id_pe_subjectInfoAccess;
extern EXTERN ASN1OBJID id_at_supportedAlgorithms;
extern EXTERN ASN1OBJID id_at_deltaRevocationList;
extern EXTERN ASN1OBJID id_ce_subjectDirectoryAttributes;
extern EXTERN ASN1OBJID id_ce_subjectKeyIdentifier;
extern EXTERN ASN1OBJID id_ce_keyUsage;
extern EXTERN ASN1OBJID id_ce_privateKeyUsagePeriod;
extern EXTERN ASN1OBJID id_ce_subjectAltName;
extern EXTERN ASN1OBJID id_ce_issuerAltName;
extern EXTERN ASN1OBJID id_ce_basicConstraints;
extern EXTERN ASN1OBJID id_ce_cRLNumber;
extern EXTERN ASN1OBJID id_ce_reasonCode;
extern EXTERN ASN1OBJID id_ce_instructionCode;
extern EXTERN ASN1OBJID id_ce_invalidityDate;
extern EXTERN ASN1OBJID id_ce_deltaCRLIndicator;
extern EXTERN ASN1OBJID id_ce_issuingDistributionPoint;
extern EXTERN ASN1OBJID id_ce_certificateIssuer;
extern EXTERN ASN1OBJID id_ce_nameConstraint;
extern EXTERN ASN1OBJID id_ce_cRLDistributionPoints;
extern EXTERN ASN1OBJID id_ce_certificatePolicies;
extern EXTERN ASN1OBJID id_ce_policyMappings;
extern EXTERN ASN1OBJID id_ce_authorityKeyIdentifier;
extern EXTERN ASN1OBJID id_ce_policyConstraints;
extern EXTERN ASN1OBJID id_ce_extKeyUsage;
extern EXTERN ASN1OBJID id_mr_certificateExactMatch;
extern EXTERN ASN1OBJID id_mr_certificateMatch;
extern EXTERN ASN1OBJID id_mr_certificatePairExactMatch;
extern EXTERN ASN1OBJID id_mr_certificatePairMatch;
extern EXTERN ASN1OBJID id_mr_certificateListExactMatch;
extern EXTERN ASN1OBJID id_mr_certificateListMatch;
extern EXTERN ASN1OBJID id_mr_algorithmIdentifierMatch;
extern EXTERN ASN1OBJID id_ce_freshestCRL;
extern EXTERN ASN1OBJID id_ce_inhibitAnyPolicy;

}
#endif
