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

#include <stdio.h>
#include <stdlib.h>
#include "asn1BerCppTypes.h"
#include "rtTable.h"
#include "ASN1CBitStr.h"
#include "ASN1CSeqOfList.h"
#include "PKIX1Explicit88.h"
#include "CertificateExtensions.h"
#include "PKIXCRMF.h"
#include "CPPKIXCMP.h"
#include "PKIX1Explicit88BaseTypes.h"
namespace asn1data {

/**************************************************************/
/*                                                            */
/*  PKIProtection                                             */
/*                                                            */
/**************************************************************/

typedef ASN1TDynBitStr ASN1T_PKIProtection;

class EXTERN ASN1C_PKIProtection :
   public ASN1CBitStr
{
protected:
   ASN1T_PKIProtection& msgData;
public:
   ASN1C_PKIProtection (ASN1T_PKIProtection& data);
   ASN1C_PKIProtection (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIProtection& data);
   ASN1C_PKIProtection (ASN1C_PKIProtection& 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_PKIProtection& getCopy (ASN1T_PKIProtection* pDstData = 0);
   ASN1T_PKIProtection* newCopy ();

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

EXTERN int asn1E_PKIProtection (ASN1CTXT* pctxt,
   ASN1T_PKIProtection *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIProtection (ASN1CTXT* pctxt,
   ASN1T_PKIProtection *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIProtection (ASN1CTXT *pctxt, ASN1T_PKIProtection* pSrcValue, ASN1T_PKIProtection* pDstValue);

EXTERN void asn1Free_PKIProtection (ASN1CTXT *pctxt, ASN1T_PKIProtection* pvalue);

/**************************************************************/
/*                                                            */
/*  PasswordBasedMac                                          */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_PasswordBasedMac;

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

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

EXTERN int asn1E_PasswordBasedMac (ASN1CTXT* pctxt,
   ASN1T_PasswordBasedMac *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PasswordBasedMac (ASN1CTXT* pctxt,
   ASN1T_PasswordBasedMac *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PasswordBasedMac (ASN1CTXT *pctxt, ASN1T_PasswordBasedMac* pSrcValue, ASN1T_PasswordBasedMac* pDstValue);

/**************************************************************/
/*                                                            */
/*  DHBasedMac                                                */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_DHBasedMac;

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

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

EXTERN int asn1E_DHBasedMac (ASN1CTXT* pctxt,
   ASN1T_DHBasedMac *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DHBasedMac (ASN1CTXT* pctxt,
   ASN1T_DHBasedMac *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_DHBasedMac (ASN1CTXT *pctxt, ASN1T_DHBasedMac* pSrcValue, ASN1T_DHBasedMac* pDstValue);

/**************************************************************/
/*                                                            */
/*  PKIHeader_pvno                                            */
/*                                                            */
/**************************************************************/

struct EXTERN PKIHeader_pvno {
   enum Root {
      ietf_version2 = 1
   } ;
} ;

typedef ASN1UINT ASN1T_PKIHeader_pvno;

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

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

EXTERN int asn1E_PKIHeader_pvno (ASN1CTXT* pctxt,
   ASN1T_PKIHeader_pvno *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIHeader_pvno (ASN1CTXT* pctxt,
   ASN1T_PKIHeader_pvno *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIHeader_pvno (ASN1CTXT *pctxt, ASN1T_PKIHeader_pvno* pSrcValue, ASN1T_PKIHeader_pvno* pDstValue);

/**************************************************************/
/*                                                            */
/*  PKIStatus                                                 */
/*                                                            */
/**************************************************************/

struct EXTERN PKIStatus {
   enum Root {
      granted = 0,
      grantedWithMods = 1,
      rejection = 2,
      waiting = 3,
      revocationWarning = 4,
      revocationNotification = 5,
      keyUpdateWarning = 6
   } ;
} ;

typedef ASN1UINT ASN1T_PKIStatus;

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

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

EXTERN int asn1E_PKIStatus (ASN1CTXT* pctxt,
   ASN1T_PKIStatus *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIStatus (ASN1CTXT* pctxt,
   ASN1T_PKIStatus *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIStatus (ASN1CTXT *pctxt, ASN1T_PKIStatus* pSrcValue, ASN1T_PKIStatus* pDstValue);

/**************************************************************/
/*                                                            */
/*  PKIFailureInfo                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIFailureInfo;

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

class EXTERN ASN1C_PKIFailureInfo :
   public ASN1CBitStr
{
protected:
   ASN1T_PKIFailureInfo& msgData;
public:
   // named bits
   enum { badAlg = 0, badMessageCheck = 1, badRequest = 2, badTime = 3, badCertId = 4, badDataFormat = 5, wrongAuthority = 6, incorrectData = 7, missingTimeStamp = 8, badPOP = 9, timeNotAvailable = 14, unacceptedPolicy = 15, unacceptedExtension = 16, addInfoNotAvailable = 17, systemFailure = 25 };

   ASN1C_PKIFailureInfo (ASN1T_PKIFailureInfo& data);
   ASN1C_PKIFailureInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIFailureInfo& data);
   ASN1C_PKIFailureInfo (ASN1C_PKIFailureInfo& 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_PKIFailureInfo& getCopy (ASN1T_PKIFailureInfo* pDstData = 0);
   ASN1T_PKIFailureInfo* newCopy ();

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

EXTERN int asn1E_PKIFailureInfo (ASN1CTXT* pctxt,
   ASN1T_PKIFailureInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIFailureInfo (ASN1CTXT* pctxt,
   ASN1T_PKIFailureInfo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIFailureInfo (ASN1CTXT *pctxt, ASN1T_PKIFailureInfo* pSrcValue, ASN1T_PKIFailureInfo* pDstValue);

/**************************************************************/
/*                                                            */
/*  PKIStatusInfo                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIStatusInfo;

typedef struct EXTERN ASN1T_PKIStatusInfo : public ASN1TPDU {
   struct {
      unsigned statusStringPresent : 1;
      unsigned failInfoPresent : 1;
   } m;
   ASN1T_PKIStatus status;
   ASN1T_PKIFreeText statusString;
   ASN1T_PKIFailureInfo failInfo;
   ASN1T_PKIStatusInfo ();
   ASN1T_PKIStatusInfo (ASN1C_PKIStatusInfo& srcData);
   ~ASN1T_PKIStatusInfo ();
} ASN1T_PKIStatusInfo;

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

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

EXTERN int asn1E_PKIStatusInfo (ASN1CTXT* pctxt,
   ASN1T_PKIStatusInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIStatusInfo (ASN1CTXT* pctxt,
   ASN1T_PKIStatusInfo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIStatusInfo (ASN1CTXT *pctxt, ASN1T_PKIStatusInfo* pSrcValue, ASN1T_PKIStatusInfo* pDstValue);

EXTERN void asn1Free_PKIStatusInfo (ASN1CTXT *pctxt, ASN1T_PKIStatusInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  _itSignKeyPairTypes_Type                                  */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C__itSignKeyPairTypes_Type :
   public ASN1CSeqOfList
{
protected:
   ASN1T__itSignKeyPairTypes_Type& msgData;
public:
   ASN1C__itSignKeyPairTypes_Type (ASN1T__itSignKeyPairTypes_Type& data);
   ASN1C__itSignKeyPairTypes_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itSignKeyPairTypes_Type& data);
   ASN1C__itSignKeyPairTypes_Type (ASN1C__itSignKeyPairTypes_Type& original);

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

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

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

   ASN1C__itSignKeyPairTypes_Type& operator= (ASN1C__itSignKeyPairTypes_Type& srcData);
   void Append (ASN1T_AlgorithmIdentifier * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__itSignKeyPairTypes_Type (ASN1CTXT* pctxt,
   ASN1T__itSignKeyPairTypes_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itSignKeyPairTypes_Type (ASN1CTXT* pctxt,
   ASN1T__itSignKeyPairTypes_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itSignKeyPairTypes_Type (ASN1CTXT *pctxt, ASN1T__itSignKeyPairTypes_Type* pSrcValue, ASN1T__itSignKeyPairTypes_Type* pDstValue);

EXTERN void asn1Free__itSignKeyPairTypes_Type (ASN1CTXT *pctxt, ASN1T__itSignKeyPairTypes_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _itEncKeyPairTypes_Type                                   */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C__itEncKeyPairTypes_Type :
   public ASN1CSeqOfList
{
protected:
   ASN1T__itEncKeyPairTypes_Type& msgData;
public:
   ASN1C__itEncKeyPairTypes_Type (ASN1T__itEncKeyPairTypes_Type& data);
   ASN1C__itEncKeyPairTypes_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itEncKeyPairTypes_Type& data);
   ASN1C__itEncKeyPairTypes_Type (ASN1C__itEncKeyPairTypes_Type& original);

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

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

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

   ASN1C__itEncKeyPairTypes_Type& operator= (ASN1C__itEncKeyPairTypes_Type& srcData);
   void Append (ASN1T_AlgorithmIdentifier * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__itEncKeyPairTypes_Type (ASN1CTXT* pctxt,
   ASN1T__itEncKeyPairTypes_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itEncKeyPairTypes_Type (ASN1CTXT* pctxt,
   ASN1T__itEncKeyPairTypes_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itEncKeyPairTypes_Type (ASN1CTXT *pctxt, ASN1T__itEncKeyPairTypes_Type* pSrcValue, ASN1T__itEncKeyPairTypes_Type* pDstValue);

EXTERN void asn1Free__itEncKeyPairTypes_Type (ASN1CTXT *pctxt, ASN1T__itEncKeyPairTypes_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  CAKeyUpdAnnContent                                        */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CAKeyUpdAnnContent;

typedef struct EXTERN ASN1T_CAKeyUpdAnnContent : public ASN1TPDU {
   ASN1T_Certificate oldWithNew;
   ASN1T_Certificate newWithOld;
   ASN1T_Certificate newWithNew;
   ASN1T_CAKeyUpdAnnContent ();
   ASN1T_CAKeyUpdAnnContent (ASN1C_CAKeyUpdAnnContent& srcData);
   ~ASN1T_CAKeyUpdAnnContent ();
} ASN1T_CAKeyUpdAnnContent;

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

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

EXTERN int asn1E_CAKeyUpdAnnContent (ASN1CTXT* pctxt,
   ASN1T_CAKeyUpdAnnContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CAKeyUpdAnnContent (ASN1CTXT* pctxt,
   ASN1T_CAKeyUpdAnnContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CAKeyUpdAnnContent (ASN1CTXT *pctxt, ASN1T_CAKeyUpdAnnContent* pSrcValue, ASN1T_CAKeyUpdAnnContent* pDstValue);

EXTERN void asn1Free_CAKeyUpdAnnContent (ASN1CTXT *pctxt, ASN1T_CAKeyUpdAnnContent* pvalue);

/**************************************************************/
/*                                                            */
/*  RevDetails                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RevDetails;

typedef struct EXTERN ASN1T_RevDetails : public ASN1TPDU {
   struct {
      unsigned revocationReasonPresent : 1;
      unsigned badSinceDatePresent : 1;
      unsigned crlEntryDetailsPresent : 1;
   } m;
   ASN1T_CertTemplate certDetails;
   ASN1T_ReasonFlags revocationReason;
   ASN1GeneralizedTime badSinceDate;
   ASN1T_Extensions crlEntryDetails;
   ASN1T_RevDetails ();
   ASN1T_RevDetails (ASN1C_RevDetails& srcData);
   ~ASN1T_RevDetails ();
} ASN1T_RevDetails;

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

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

EXTERN int asn1E_RevDetails (ASN1CTXT* pctxt,
   ASN1T_RevDetails *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevDetails (ASN1CTXT* pctxt,
   ASN1T_RevDetails *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevDetails (ASN1CTXT *pctxt, ASN1T_RevDetails* pSrcValue, ASN1T_RevDetails* pDstValue);

EXTERN void asn1Free_RevDetails (ASN1CTXT *pctxt, ASN1T_RevDetails* pvalue);

/**************************************************************/
/*                                                            */
/*  RevRepContent_status                                      */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_RevRepContent_status :
   public ASN1CSeqOfList
{
protected:
   ASN1T_RevRepContent_status& msgData;
public:
   ASN1C_RevRepContent_status (ASN1T_RevRepContent_status& data);
   ASN1C_RevRepContent_status (
      ASN1MessageBufferIF& msgBuf, ASN1T_RevRepContent_status& data);
   ASN1C_RevRepContent_status (ASN1C_RevRepContent_status& 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_RevRepContent_status& getCopy (ASN1T_RevRepContent_status* pDstData = 0);
   ASN1T_RevRepContent_status* newCopy ();

   ASN1C_RevRepContent_status& operator= (ASN1C_RevRepContent_status& srcData);
   void Append (ASN1T_PKIStatusInfo * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_RevRepContent_status (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_status *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevRepContent_status (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_status *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevRepContent_status (ASN1CTXT *pctxt, ASN1T_RevRepContent_status* pSrcValue, ASN1T_RevRepContent_status* pDstValue);

EXTERN void asn1Free_RevRepContent_status (ASN1CTXT *pctxt, ASN1T_RevRepContent_status* pvalue);

/**************************************************************/
/*                                                            */
/*  RevRepContent_revCerts                                    */
/*                                                            */
/**************************************************************/

#define TV_RevRepContent_revCerts	(TM_CTXT|TM_CONS|0)

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

class EXTERN ASN1C_RevRepContent_revCerts :
   public ASN1CSeqOfList
{
protected:
   ASN1T_RevRepContent_revCerts& msgData;
public:
   ASN1C_RevRepContent_revCerts (ASN1T_RevRepContent_revCerts& data);
   ASN1C_RevRepContent_revCerts (
      ASN1MessageBufferIF& msgBuf, ASN1T_RevRepContent_revCerts& data);
   ASN1C_RevRepContent_revCerts (ASN1C_RevRepContent_revCerts& 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_RevRepContent_revCerts& getCopy (ASN1T_RevRepContent_revCerts* pDstData = 0);
   ASN1T_RevRepContent_revCerts* newCopy ();

   ASN1C_RevRepContent_revCerts& operator= (ASN1C_RevRepContent_revCerts& srcData);
   void Append (ASN1T_CertId * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_RevRepContent_revCerts (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_revCerts *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevRepContent_revCerts (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_revCerts *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevRepContent_revCerts (ASN1CTXT *pctxt, ASN1T_RevRepContent_revCerts* pSrcValue, ASN1T_RevRepContent_revCerts* pDstValue);

EXTERN void asn1Free_RevRepContent_revCerts (ASN1CTXT *pctxt, ASN1T_RevRepContent_revCerts* pvalue);

/**************************************************************/
/*                                                            */
/*  RevRepContent_crls                                        */
/*                                                            */
/**************************************************************/

#define TV_RevRepContent_crls	(TM_CTXT|TM_CONS|1)

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

class EXTERN ASN1C_RevRepContent_crls :
   public ASN1CSeqOfList
{
protected:
   ASN1T_RevRepContent_crls& msgData;
public:
   ASN1C_RevRepContent_crls (ASN1T_RevRepContent_crls& data);
   ASN1C_RevRepContent_crls (
      ASN1MessageBufferIF& msgBuf, ASN1T_RevRepContent_crls& data);
   ASN1C_RevRepContent_crls (ASN1C_RevRepContent_crls& 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_RevRepContent_crls& getCopy (ASN1T_RevRepContent_crls* pDstData = 0);
   ASN1T_RevRepContent_crls* newCopy ();

   ASN1C_RevRepContent_crls& operator= (ASN1C_RevRepContent_crls& srcData);
   void Append (ASN1T_CertificateList * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_RevRepContent_crls (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_crls *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevRepContent_crls (ASN1CTXT* pctxt,
   ASN1T_RevRepContent_crls *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevRepContent_crls (ASN1CTXT *pctxt, ASN1T_RevRepContent_crls* pSrcValue, ASN1T_RevRepContent_crls* pDstValue);

EXTERN void asn1Free_RevRepContent_crls (ASN1CTXT *pctxt, ASN1T_RevRepContent_crls* pvalue);

/**************************************************************/
/*                                                            */
/*  RevRepContent                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RevRepContent;

typedef struct EXTERN ASN1T_RevRepContent : public ASN1TPDU {
   struct {
      unsigned revCertsPresent : 1;
      unsigned crlsPresent : 1;
   } m;
   ASN1T_RevRepContent_status status;
   ASN1T_RevRepContent_revCerts revCerts;
   ASN1T_RevRepContent_crls crls;
   ASN1T_RevRepContent ();
   ASN1T_RevRepContent (ASN1C_RevRepContent& srcData);
   ~ASN1T_RevRepContent ();
} ASN1T_RevRepContent;

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

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

EXTERN int asn1E_RevRepContent (ASN1CTXT* pctxt,
   ASN1T_RevRepContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevRepContent (ASN1CTXT* pctxt,
   ASN1T_RevRepContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevRepContent (ASN1CTXT *pctxt, ASN1T_RevRepContent* pSrcValue, ASN1T_RevRepContent* pDstValue);

EXTERN void asn1Free_RevRepContent (ASN1CTXT *pctxt, ASN1T_RevRepContent* pvalue);

/**************************************************************/
/*                                                            */
/*  _itCryptoProOrganization_Type                             */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__itCryptoProOrganization_Type;

class EXTERN ASN1C__itCryptoProOrganization_Type :
   public ASN1CType
{
protected:
   ASN1T__itCryptoProOrganization_Type& msgData;
public:
   ASN1C__itCryptoProOrganization_Type (ASN1T__itCryptoProOrganization_Type& data);
   ASN1C__itCryptoProOrganization_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itCryptoProOrganization_Type& data);
   ASN1C__itCryptoProOrganization_Type (ASN1C__itCryptoProOrganization_Type& original);

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

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

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

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

EXTERN int asn1E__itCryptoProOrganization_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProOrganization_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itCryptoProOrganization_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProOrganization_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itCryptoProOrganization_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProOrganization_Type* pSrcValue, ASN1T__itCryptoProOrganization_Type* pDstValue);

EXTERN void asn1Free__itCryptoProOrganization_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProOrganization_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _itCryptoProLicense_Type                                  */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__itCryptoProLicense_Type;

class EXTERN ASN1C__itCryptoProLicense_Type :
   public ASN1CType
{
protected:
   ASN1T__itCryptoProLicense_Type& msgData;
public:
   ASN1C__itCryptoProLicense_Type (ASN1T__itCryptoProLicense_Type& data);
   ASN1C__itCryptoProLicense_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itCryptoProLicense_Type& data);
   ASN1C__itCryptoProLicense_Type (ASN1C__itCryptoProLicense_Type& original);

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

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

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

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

EXTERN int asn1E__itCryptoProLicense_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProLicense_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itCryptoProLicense_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProLicense_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itCryptoProLicense_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProLicense_Type* pSrcValue, ASN1T__itCryptoProLicense_Type* pDstValue);

EXTERN void asn1Free__itCryptoProLicense_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProLicense_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _itCryptoProPolicy_Type                                   */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__itCryptoProPolicy_Type;

class EXTERN ASN1C__itCryptoProPolicy_Type :
   public ASN1CType
{
protected:
   ASN1T__itCryptoProPolicy_Type& msgData;
public:
   ASN1C__itCryptoProPolicy_Type (ASN1T__itCryptoProPolicy_Type& data);
   ASN1C__itCryptoProPolicy_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itCryptoProPolicy_Type& data);
   ASN1C__itCryptoProPolicy_Type (ASN1C__itCryptoProPolicy_Type& original);

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

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

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

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

EXTERN int asn1E__itCryptoProPolicy_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProPolicy_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itCryptoProPolicy_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProPolicy_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itCryptoProPolicy_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProPolicy_Type* pSrcValue, ASN1T__itCryptoProPolicy_Type* pDstValue);

EXTERN void asn1Free__itCryptoProPolicy_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProPolicy_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _itCryptoProOfficial_Type                                 */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__itCryptoProOfficial_Type;

class EXTERN ASN1C__itCryptoProOfficial_Type :
   public ASN1CType
{
protected:
   ASN1T__itCryptoProOfficial_Type& msgData;
public:
   ASN1C__itCryptoProOfficial_Type (ASN1T__itCryptoProOfficial_Type& data);
   ASN1C__itCryptoProOfficial_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itCryptoProOfficial_Type& data);
   ASN1C__itCryptoProOfficial_Type (ASN1C__itCryptoProOfficial_Type& original);

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

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

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

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

EXTERN int asn1E__itCryptoProOfficial_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProOfficial_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itCryptoProOfficial_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProOfficial_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itCryptoProOfficial_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProOfficial_Type* pSrcValue, ASN1T__itCryptoProOfficial_Type* pDstValue);

EXTERN void asn1Free__itCryptoProOfficial_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProOfficial_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  _itCryptoProCertificate_Type                              */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T__itCryptoProCertificate_Type;

class EXTERN ASN1C__itCryptoProCertificate_Type :
   public ASN1CType
{
protected:
   ASN1T__itCryptoProCertificate_Type& msgData;
public:
   ASN1C__itCryptoProCertificate_Type (ASN1T__itCryptoProCertificate_Type& data);
   ASN1C__itCryptoProCertificate_Type (
      ASN1MessageBufferIF& msgBuf, ASN1T__itCryptoProCertificate_Type& data);
   ASN1C__itCryptoProCertificate_Type (ASN1C__itCryptoProCertificate_Type& original);

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

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

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

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

EXTERN int asn1E__itCryptoProCertificate_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProCertificate_Type *pvalue, ASN1TagType tagging);

EXTERN int asn1D__itCryptoProCertificate_Type (ASN1CTXT* pctxt,
   ASN1T__itCryptoProCertificate_Type *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__itCryptoProCertificate_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProCertificate_Type* pSrcValue, ASN1T__itCryptoProCertificate_Type* pDstValue);

EXTERN void asn1Free__itCryptoProCertificate_Type (ASN1CTXT *pctxt, ASN1T__itCryptoProCertificate_Type* pvalue);

/**************************************************************/
/*                                                            */
/*  InfoTypeAndValue                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_InfoTypeAndValue;

typedef struct EXTERN ASN1T_InfoTypeAndValue : public ASN1TPDU {
   struct {
      unsigned infoValuePresent : 1;
   } m;
   ASN1TObjId infoType;
   Asn1TObject infoValue;
   ASN1T_InfoTypeAndValue ();
   ASN1T_InfoTypeAndValue (ASN1C_InfoTypeAndValue& srcData);
   ~ASN1T_InfoTypeAndValue ();
} ASN1T_InfoTypeAndValue;

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

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

EXTERN int asn1E_InfoTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_InfoTypeAndValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_InfoTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_InfoTypeAndValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XETC_InfoTypeAndValue (ASN1CTXT* pctxt,
    ASN1T_InfoTypeAndValue *pvalue);

EXTERN int asn1XDTC_InfoTypeAndValue (ASN1CtxtPtr& pctxt,
    ASN1T_InfoTypeAndValue *pvalue);

EXTERN int asn1ETC_InfoTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_InfoTypeAndValue *pvalue);

EXTERN int asn1DTC_InfoTypeAndValue (ASN1CTXT* pctxt,
   ASN1T_InfoTypeAndValue *pvalue);

EXTERN void asn1Copy_InfoTypeAndValue (ASN1CTXT *pctxt, ASN1T_InfoTypeAndValue* pSrcValue, ASN1T_InfoTypeAndValue* pDstValue);

EXTERN void asn1Free_InfoTypeAndValue (ASN1CTXT *pctxt, ASN1T_InfoTypeAndValue* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIHeader_generalInfo                                     */
/*                                                            */
/**************************************************************/

#define TV_PKIHeader_generalInfo	(TM_CTXT|TM_CONS|8)

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

class EXTERN ASN1C_PKIHeader_generalInfo :
   public ASN1CSeqOfList
{
protected:
   ASN1T_PKIHeader_generalInfo& msgData;
public:
   ASN1C_PKIHeader_generalInfo (ASN1T_PKIHeader_generalInfo& data);
   ASN1C_PKIHeader_generalInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIHeader_generalInfo& data);
   ASN1C_PKIHeader_generalInfo (ASN1C_PKIHeader_generalInfo& 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_PKIHeader_generalInfo& getCopy (ASN1T_PKIHeader_generalInfo* pDstData = 0);
   ASN1T_PKIHeader_generalInfo* newCopy ();

   ASN1C_PKIHeader_generalInfo& operator= (ASN1C_PKIHeader_generalInfo& srcData);
   void Append (ASN1T_InfoTypeAndValue * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_PKIHeader_generalInfo (ASN1CTXT* pctxt,
   ASN1T_PKIHeader_generalInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIHeader_generalInfo (ASN1CTXT* pctxt,
   ASN1T_PKIHeader_generalInfo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIHeader_generalInfo (ASN1CTXT *pctxt, ASN1T_PKIHeader_generalInfo* pSrcValue, ASN1T_PKIHeader_generalInfo* pDstValue);

EXTERN void asn1Free_PKIHeader_generalInfo (ASN1CTXT *pctxt, ASN1T_PKIHeader_generalInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIHeader                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIHeader;

typedef struct EXTERN ASN1T_PKIHeader : public ASN1TPDU {
   struct {
      unsigned messageTimePresent : 1;
      unsigned protectionAlgPresent : 1;
      unsigned senderKIDPresent : 1;
      unsigned recipKIDPresent : 1;
      unsigned transactionIDPresent : 1;
      unsigned senderNoncePresent : 1;
      unsigned recipNoncePresent : 1;
      unsigned freeTextPresent : 1;
      unsigned generalInfoPresent : 1;
   } m;
   ASN1T_PKIHeader_pvno pvno;
   ASN1T_GeneralName sender;
   ASN1T_GeneralName recipient;
   ASN1GeneralizedTime messageTime;
   ASN1T_AlgorithmIdentifier protectionAlg;
   ASN1T_KeyIdentifier senderKID;
   ASN1T_KeyIdentifier recipKID;
   ASN1TDynOctStr transactionID;
   ASN1TDynOctStr senderNonce;
   ASN1TDynOctStr recipNonce;
   ASN1T_PKIFreeText freeText;
   ASN1T_PKIHeader_generalInfo generalInfo;
   ASN1T_PKIHeader ();
   ASN1T_PKIHeader (ASN1C_PKIHeader& srcData);
   ~ASN1T_PKIHeader ();
} ASN1T_PKIHeader;

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

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

EXTERN int asn1E_PKIHeader (ASN1CTXT* pctxt,
   ASN1T_PKIHeader *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIHeader (ASN1CTXT* pctxt,
   ASN1T_PKIHeader *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIHeader (ASN1CTXT *pctxt, ASN1T_PKIHeader* pSrcValue, ASN1T_PKIHeader* pDstValue);

EXTERN void asn1Free_PKIHeader (ASN1CTXT *pctxt, ASN1T_PKIHeader* pvalue);

/**************************************************************/
/*                                                            */
/*  CertRepMessage_caPubs                                     */
/*                                                            */
/**************************************************************/

#define TV_CertRepMessage_caPubs	(TM_CTXT|TM_CONS|1)

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

class EXTERN ASN1C_CertRepMessage_caPubs :
   public ASN1CSeqOfList
{
protected:
   ASN1T_CertRepMessage_caPubs& msgData;
public:
   ASN1C_CertRepMessage_caPubs (ASN1T_CertRepMessage_caPubs& data);
   ASN1C_CertRepMessage_caPubs (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertRepMessage_caPubs& data);
   ASN1C_CertRepMessage_caPubs (ASN1C_CertRepMessage_caPubs& 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_CertRepMessage_caPubs& getCopy (ASN1T_CertRepMessage_caPubs* pDstData = 0);
   ASN1T_CertRepMessage_caPubs* newCopy ();

   ASN1C_CertRepMessage_caPubs& operator= (ASN1C_CertRepMessage_caPubs& srcData);
   void Append (ASN1T_Certificate * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_CertRepMessage_caPubs (ASN1CTXT* pctxt,
   ASN1T_CertRepMessage_caPubs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertRepMessage_caPubs (ASN1CTXT* pctxt,
   ASN1T_CertRepMessage_caPubs *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertRepMessage_caPubs (ASN1CTXT *pctxt, ASN1T_CertRepMessage_caPubs* pSrcValue, ASN1T_CertRepMessage_caPubs* pDstValue);

EXTERN void asn1Free_CertRepMessage_caPubs (ASN1CTXT *pctxt, ASN1T_CertRepMessage_caPubs* pvalue);

/**************************************************************/
/*                                                            */
/*  CertOrEncCert                                             */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_CertOrEncCert_certificate     1
#define T_CertOrEncCert_encryptedCert   2

class EXTERN ASN1C_CertOrEncCert;

typedef struct EXTERN ASN1T_CertOrEncCert : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_Certificate *certificate;
      /* t = 2 */
      ASN1T_EncryptedValue *encryptedCert;
   } u;
   ASN1T_CertOrEncCert () {}
   ASN1T_CertOrEncCert (ASN1C_CertOrEncCert& srcData);
   ~ASN1T_CertOrEncCert ();
} ASN1T_CertOrEncCert;

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

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

EXTERN int asn1E_CertOrEncCert (ASN1CTXT* pctxt,
   ASN1T_CertOrEncCert *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertOrEncCert (ASN1CTXT* pctxt,
   ASN1T_CertOrEncCert *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertOrEncCert (ASN1CTXT *pctxt, ASN1T_CertOrEncCert* pSrcValue, ASN1T_CertOrEncCert* pDstValue);

EXTERN void asn1Free_CertOrEncCert (ASN1CTXT *pctxt, ASN1T_CertOrEncCert* pvalue);

/**************************************************************/
/*                                                            */
/*  CertifiedKeyPair                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertifiedKeyPair;

typedef struct EXTERN ASN1T_CertifiedKeyPair : public ASN1TPDU {
   struct {
      unsigned privateKeyPresent : 1;
      unsigned publicationInfoPresent : 1;
   } m;
   ASN1T_CertOrEncCert certOrEncCert;
   ASN1T_EncryptedValue privateKey;
   ASN1T_PKIPublicationInfo publicationInfo;
   ASN1T_CertifiedKeyPair ();
   ASN1T_CertifiedKeyPair (ASN1C_CertifiedKeyPair& srcData);
   ~ASN1T_CertifiedKeyPair ();
} ASN1T_CertifiedKeyPair;

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

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

EXTERN int asn1E_CertifiedKeyPair (ASN1CTXT* pctxt,
   ASN1T_CertifiedKeyPair *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertifiedKeyPair (ASN1CTXT* pctxt,
   ASN1T_CertifiedKeyPair *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertifiedKeyPair (ASN1CTXT *pctxt, ASN1T_CertifiedKeyPair* pSrcValue, ASN1T_CertifiedKeyPair* pDstValue);

EXTERN void asn1Free_CertifiedKeyPair (ASN1CTXT *pctxt, ASN1T_CertifiedKeyPair* pvalue);

/**************************************************************/
/*                                                            */
/*  CertResponse                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertResponse;

typedef struct EXTERN ASN1T_CertResponse : public ASN1TPDU {
   struct {
      unsigned certifiedKeyPairPresent : 1;
      unsigned rspInfoPresent : 1;
   } m;
   ASN1INT certReqId;
   ASN1T_PKIStatusInfo status;
   ASN1T_CertifiedKeyPair certifiedKeyPair;
   ASN1TDynOctStr rspInfo;
   ASN1T_CertResponse ();
   ASN1T_CertResponse (ASN1C_CertResponse& srcData);
   ~ASN1T_CertResponse ();
} ASN1T_CertResponse;

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

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

EXTERN int asn1E_CertResponse (ASN1CTXT* pctxt,
   ASN1T_CertResponse *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertResponse (ASN1CTXT* pctxt,
   ASN1T_CertResponse *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertResponse (ASN1CTXT *pctxt, ASN1T_CertResponse* pSrcValue, ASN1T_CertResponse* pDstValue);

EXTERN void asn1Free_CertResponse (ASN1CTXT *pctxt, ASN1T_CertResponse* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfCertResponse                                        */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C__SeqOfCertResponse :
   public ASN1CSeqOfList
{
protected:
   ASN1T__SeqOfCertResponse& msgData;
public:
   ASN1C__SeqOfCertResponse (ASN1T__SeqOfCertResponse& data);
   ASN1C__SeqOfCertResponse (
      ASN1MessageBufferIF& msgBuf, ASN1T__SeqOfCertResponse& data);
   ASN1C__SeqOfCertResponse (ASN1C__SeqOfCertResponse& 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__SeqOfCertResponse& getCopy (ASN1T__SeqOfCertResponse* pDstData = 0);
   ASN1T__SeqOfCertResponse* newCopy ();

   ASN1C__SeqOfCertResponse& operator= (ASN1C__SeqOfCertResponse& srcData);
   void Append (ASN1T_CertResponse * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SeqOfCertResponse (ASN1CTXT* pctxt,
   ASN1T__SeqOfCertResponse *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfCertResponse (ASN1CTXT* pctxt,
   ASN1T__SeqOfCertResponse *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfCertResponse (ASN1CTXT *pctxt, ASN1T__SeqOfCertResponse* pSrcValue, ASN1T__SeqOfCertResponse* pDstValue);

EXTERN void asn1Free__SeqOfCertResponse (ASN1CTXT *pctxt, ASN1T__SeqOfCertResponse* pvalue);

/**************************************************************/
/*                                                            */
/*  CertRepMessage                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertRepMessage;

typedef struct EXTERN ASN1T_CertRepMessage : public ASN1TPDU {
   struct {
      unsigned caPubsPresent : 1;
   } m;
   ASN1T_CertRepMessage_caPubs caPubs;
   ASN1T__SeqOfCertResponse response;
   ASN1T_CertRepMessage ();
   ASN1T_CertRepMessage (ASN1C_CertRepMessage& srcData);
   ~ASN1T_CertRepMessage ();
} ASN1T_CertRepMessage;

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

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

EXTERN int asn1E_CertRepMessage (ASN1CTXT* pctxt,
   ASN1T_CertRepMessage *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertRepMessage (ASN1CTXT* pctxt,
   ASN1T_CertRepMessage *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertRepMessage (ASN1CTXT *pctxt, ASN1T_CertRepMessage* pSrcValue, ASN1T_CertRepMessage* pDstValue);

EXTERN void asn1Free_CertRepMessage (ASN1CTXT *pctxt, ASN1T_CertRepMessage* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificationRequest_certificationRequestInfo_subjectPub  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo;

typedef struct EXTERN ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo : public ASN1TPDU {
   ASN1T_AlgorithmIdentifier algorithm;
   ASN1TDynBitStr subjectPublicKey;
   ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo ();
   ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo (ASN1C_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo& srcData);
   ~ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo ();
} ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo;

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

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

EXTERN int asn1E_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo (ASN1CTXT *pctxt, ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo* pSrcValue, ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo* pDstValue);

EXTERN void asn1Free_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo (ASN1CTXT *pctxt, ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  _SetOfAttribute                                           */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C__SetOfAttribute :
   public ASN1CSeqOfList
{
protected:
   ASN1T__SetOfAttribute& msgData;
public:
   ASN1C__SetOfAttribute (ASN1T__SetOfAttribute& data);
   ASN1C__SetOfAttribute (
      ASN1MessageBufferIF& msgBuf, ASN1T__SetOfAttribute& data);
   ASN1C__SetOfAttribute (ASN1C__SetOfAttribute& 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__SetOfAttribute& getCopy (ASN1T__SetOfAttribute* pDstData = 0);
   ASN1T__SetOfAttribute* newCopy ();

   ASN1C__SetOfAttribute& operator= (ASN1C__SetOfAttribute& srcData);
   void Append (ASN1T_Attribute * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SetOfAttribute (ASN1CTXT* pctxt,
   ASN1T__SetOfAttribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SetOfAttribute (ASN1CTXT* pctxt,
   ASN1T__SetOfAttribute *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SetOfAttribute (ASN1CTXT *pctxt, ASN1T__SetOfAttribute* pSrcValue, ASN1T__SetOfAttribute* pDstValue);

EXTERN void asn1Free__SetOfAttribute (ASN1CTXT *pctxt, ASN1T__SetOfAttribute* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificationRequest_certificationRequestInfo             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificationRequest_certificationRequestInfo;

typedef struct EXTERN ASN1T_CertificationRequest_certificationRequestInfo : public ASN1TPDU {
   ASN1INT version;
   ASN1T_Name subject;
   ASN1T_CertificationRequest_certificationRequestInfo_subjectPublicKeyInfo subjectPublicKeyInfo;
   ASN1T__SetOfAttribute attributes;
   ASN1T_CertificationRequest_certificationRequestInfo ();
   ASN1T_CertificationRequest_certificationRequestInfo (ASN1C_CertificationRequest_certificationRequestInfo& srcData);
   ~ASN1T_CertificationRequest_certificationRequestInfo ();
} ASN1T_CertificationRequest_certificationRequestInfo;

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

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

EXTERN int asn1E_CertificationRequest_certificationRequestInfo (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest_certificationRequestInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificationRequest_certificationRequestInfo (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest_certificationRequestInfo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertificationRequest_certificationRequestInfo (ASN1CTXT *pctxt, ASN1T_CertificationRequest_certificationRequestInfo* pSrcValue, ASN1T_CertificationRequest_certificationRequestInfo* pDstValue);

EXTERN void asn1Free_CertificationRequest_certificationRequestInfo (ASN1CTXT *pctxt, ASN1T_CertificationRequest_certificationRequestInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificationRequest                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertificationRequest;

typedef struct EXTERN ASN1T_CertificationRequest : public ASN1TPDU {
   ASN1T_CertificationRequest_certificationRequestInfo certificationRequestInfo;
   ASN1T_AlgorithmIdentifier signatureAlgorithm;
   ASN1TDynBitStr signature;
   ASN1T_CertificationRequest ();
   ASN1T_CertificationRequest (ASN1C_CertificationRequest& srcData);
   ~ASN1T_CertificationRequest ();
} ASN1T_CertificationRequest;

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

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

EXTERN int asn1E_CertificationRequest (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificationRequest (ASN1CTXT* pctxt,
   ASN1T_CertificationRequest *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertificationRequest (ASN1CTXT *pctxt, ASN1T_CertificationRequest* pSrcValue, ASN1T_CertificationRequest* pDstValue);

EXTERN void asn1Free_CertificationRequest (ASN1CTXT *pctxt, ASN1T_CertificationRequest* pvalue);

/**************************************************************/
/*                                                            */
/*  Challenge                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Challenge;

typedef struct EXTERN ASN1T_Challenge : public ASN1TPDU {
   struct {
      unsigned owfPresent : 1;
   } m;
   ASN1T_AlgorithmIdentifier owf;
   ASN1TDynOctStr witness;
   ASN1TDynOctStr challenge;
   ASN1T_Challenge ();
   ASN1T_Challenge (ASN1C_Challenge& srcData);
   ~ASN1T_Challenge ();
} ASN1T_Challenge;

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

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

EXTERN int asn1E_Challenge (ASN1CTXT* pctxt,
   ASN1T_Challenge *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Challenge (ASN1CTXT* pctxt,
   ASN1T_Challenge *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_Challenge (ASN1CTXT *pctxt, ASN1T_Challenge* pSrcValue, ASN1T_Challenge* pDstValue);

EXTERN void asn1Free_Challenge (ASN1CTXT *pctxt, ASN1T_Challenge* pvalue);

/**************************************************************/
/*                                                            */
/*  POPODecKeyChallContent                                    */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_POPODecKeyChallContent :
   public ASN1CSeqOfList
{
protected:
   ASN1T_POPODecKeyChallContent& msgData;
public:
   ASN1C_POPODecKeyChallContent (ASN1T_POPODecKeyChallContent& data);
   ASN1C_POPODecKeyChallContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_POPODecKeyChallContent& data);
   ASN1C_POPODecKeyChallContent (ASN1C_POPODecKeyChallContent& 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_POPODecKeyChallContent& getCopy (ASN1T_POPODecKeyChallContent* pDstData = 0);
   ASN1T_POPODecKeyChallContent* newCopy ();

   ASN1C_POPODecKeyChallContent& operator= (ASN1C_POPODecKeyChallContent& srcData);
   void Append (ASN1T_Challenge * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_POPODecKeyChallContent (ASN1CTXT* pctxt,
   ASN1T_POPODecKeyChallContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPODecKeyChallContent (ASN1CTXT* pctxt,
   ASN1T_POPODecKeyChallContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_POPODecKeyChallContent (ASN1CTXT *pctxt, ASN1T_POPODecKeyChallContent* pSrcValue, ASN1T_POPODecKeyChallContent* pDstValue);

EXTERN void asn1Free_POPODecKeyChallContent (ASN1CTXT *pctxt, ASN1T_POPODecKeyChallContent* pvalue);

/**************************************************************/
/*                                                            */
/*  POPODecKeyRespContent                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_POPODecKeyRespContent;

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

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

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

EXTERN int asn1E_POPODecKeyRespContent (ASN1CTXT* pctxt,
   ASN1T_POPODecKeyRespContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPODecKeyRespContent (ASN1CTXT* pctxt,
   ASN1T_POPODecKeyRespContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_POPODecKeyRespContent (ASN1CTXT *pctxt, ASN1T_POPODecKeyRespContent* pSrcValue, ASN1T_POPODecKeyRespContent* pDstValue);

EXTERN void asn1Free_POPODecKeyRespContent (ASN1CTXT *pctxt, ASN1T_POPODecKeyRespContent* pvalue);

/**************************************************************/
/*                                                            */
/*  KeyRecRepContent_caCerts                                  */
/*                                                            */
/**************************************************************/

#define TV_KeyRecRepContent_caCerts	(TM_CTXT|TM_CONS|1)

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

class EXTERN ASN1C_KeyRecRepContent_caCerts :
   public ASN1CSeqOfList
{
protected:
   ASN1T_KeyRecRepContent_caCerts& msgData;
public:
   ASN1C_KeyRecRepContent_caCerts (ASN1T_KeyRecRepContent_caCerts& data);
   ASN1C_KeyRecRepContent_caCerts (
      ASN1MessageBufferIF& msgBuf, ASN1T_KeyRecRepContent_caCerts& data);
   ASN1C_KeyRecRepContent_caCerts (ASN1C_KeyRecRepContent_caCerts& 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_KeyRecRepContent_caCerts& getCopy (ASN1T_KeyRecRepContent_caCerts* pDstData = 0);
   ASN1T_KeyRecRepContent_caCerts* newCopy ();

   ASN1C_KeyRecRepContent_caCerts& operator= (ASN1C_KeyRecRepContent_caCerts& srcData);
   void Append (ASN1T_Certificate * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_KeyRecRepContent_caCerts (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent_caCerts *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyRecRepContent_caCerts (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent_caCerts *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_KeyRecRepContent_caCerts (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent_caCerts* pSrcValue, ASN1T_KeyRecRepContent_caCerts* pDstValue);

EXTERN void asn1Free_KeyRecRepContent_caCerts (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent_caCerts* pvalue);

/**************************************************************/
/*                                                            */
/*  KeyRecRepContent_keyPairHist                              */
/*                                                            */
/**************************************************************/

#define TV_KeyRecRepContent_keyPairHist	(TM_CTXT|TM_CONS|2)

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

class EXTERN ASN1C_KeyRecRepContent_keyPairHist :
   public ASN1CSeqOfList
{
protected:
   ASN1T_KeyRecRepContent_keyPairHist& msgData;
public:
   ASN1C_KeyRecRepContent_keyPairHist (ASN1T_KeyRecRepContent_keyPairHist& data);
   ASN1C_KeyRecRepContent_keyPairHist (
      ASN1MessageBufferIF& msgBuf, ASN1T_KeyRecRepContent_keyPairHist& data);
   ASN1C_KeyRecRepContent_keyPairHist (ASN1C_KeyRecRepContent_keyPairHist& 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_KeyRecRepContent_keyPairHist& getCopy (ASN1T_KeyRecRepContent_keyPairHist* pDstData = 0);
   ASN1T_KeyRecRepContent_keyPairHist* newCopy ();

   ASN1C_KeyRecRepContent_keyPairHist& operator= (ASN1C_KeyRecRepContent_keyPairHist& srcData);
   void Append (ASN1T_CertifiedKeyPair * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_KeyRecRepContent_keyPairHist (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent_keyPairHist *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyRecRepContent_keyPairHist (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent_keyPairHist *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_KeyRecRepContent_keyPairHist (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent_keyPairHist* pSrcValue, ASN1T_KeyRecRepContent_keyPairHist* pDstValue);

EXTERN void asn1Free_KeyRecRepContent_keyPairHist (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent_keyPairHist* pvalue);

/**************************************************************/
/*                                                            */
/*  KeyRecRepContent                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_KeyRecRepContent;

typedef struct EXTERN ASN1T_KeyRecRepContent : public ASN1TPDU {
   struct {
      unsigned newSigCertPresent : 1;
      unsigned caCertsPresent : 1;
      unsigned keyPairHistPresent : 1;
   } m;
   ASN1T_PKIStatusInfo status;
   ASN1T_Certificate newSigCert;
   ASN1T_KeyRecRepContent_caCerts caCerts;
   ASN1T_KeyRecRepContent_keyPairHist keyPairHist;
   ASN1T_KeyRecRepContent ();
   ASN1T_KeyRecRepContent (ASN1C_KeyRecRepContent& srcData);
   ~ASN1T_KeyRecRepContent ();
} ASN1T_KeyRecRepContent;

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

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

EXTERN int asn1E_KeyRecRepContent (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyRecRepContent (ASN1CTXT* pctxt,
   ASN1T_KeyRecRepContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_KeyRecRepContent (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent* pSrcValue, ASN1T_KeyRecRepContent* pDstValue);

EXTERN void asn1Free_KeyRecRepContent (ASN1CTXT *pctxt, ASN1T_KeyRecRepContent* pvalue);

/**************************************************************/
/*                                                            */
/*  RevReqContent                                             */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_RevReqContent :
   public ASN1CSeqOfList
{
protected:
   ASN1T_RevReqContent& msgData;
public:
   ASN1C_RevReqContent (ASN1T_RevReqContent& data);
   ASN1C_RevReqContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_RevReqContent& data);
   ASN1C_RevReqContent (ASN1C_RevReqContent& 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_RevReqContent& getCopy (ASN1T_RevReqContent* pDstData = 0);
   ASN1T_RevReqContent* newCopy ();

   ASN1C_RevReqContent& operator= (ASN1C_RevReqContent& srcData);
   void Append (ASN1T_RevDetails * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_RevReqContent (ASN1CTXT* pctxt,
   ASN1T_RevReqContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevReqContent (ASN1CTXT* pctxt,
   ASN1T_RevReqContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevReqContent (ASN1CTXT *pctxt, ASN1T_RevReqContent* pSrcValue, ASN1T_RevReqContent* pDstValue);

EXTERN void asn1Free_RevReqContent (ASN1CTXT *pctxt, ASN1T_RevReqContent* pvalue);

/**************************************************************/
/*                                                            */
/*  CertAnnContent                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertAnnContent;

typedef ASN1T_Certificate ASN1T_CertAnnContent;

class EXTERN ASN1C_CertAnnContent :
   public ASN1C_Certificate
{
protected:
public:
   ASN1C_CertAnnContent (ASN1T_CertAnnContent& data);
   ASN1C_CertAnnContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertAnnContent& data);
   ASN1C_CertAnnContent (ASN1C_CertAnnContent& 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_CertAnnContent& getCopy (ASN1T_CertAnnContent* pDstData = 0);
   ASN1T_CertAnnContent* newCopy ();

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

EXTERN int asn1E_CertAnnContent (ASN1CTXT* pctxt,
   ASN1T_CertAnnContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertAnnContent (ASN1CTXT* pctxt,
   ASN1T_CertAnnContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertAnnContent (ASN1CTXT *pctxt, ASN1T_CertAnnContent* pSrcValue, ASN1T_CertAnnContent* pDstValue);

EXTERN void asn1Free_CertAnnContent (ASN1CTXT *pctxt, ASN1T_CertAnnContent* pvalue);

/**************************************************************/
/*                                                            */
/*  RevAnnContent                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RevAnnContent;

typedef struct EXTERN ASN1T_RevAnnContent : public ASN1TPDU {
   struct {
      unsigned crlDetailsPresent : 1;
   } m;
   ASN1T_PKIStatus status;
   ASN1T_CertId certId;
   ASN1GeneralizedTime willBeRevokedAt;
   ASN1GeneralizedTime badSinceDate;
   ASN1T_Extensions crlDetails;
   ASN1T_RevAnnContent ();
   ASN1T_RevAnnContent (ASN1C_RevAnnContent& srcData);
   ~ASN1T_RevAnnContent ();
} ASN1T_RevAnnContent;

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

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

EXTERN int asn1E_RevAnnContent (ASN1CTXT* pctxt,
   ASN1T_RevAnnContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevAnnContent (ASN1CTXT* pctxt,
   ASN1T_RevAnnContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevAnnContent (ASN1CTXT *pctxt, ASN1T_RevAnnContent* pSrcValue, ASN1T_RevAnnContent* pDstValue);

EXTERN void asn1Free_RevAnnContent (ASN1CTXT *pctxt, ASN1T_RevAnnContent* pvalue);

/**************************************************************/
/*                                                            */
/*  CRLAnnContent                                             */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_CRLAnnContent :
   public ASN1CSeqOfList
{
protected:
   ASN1T_CRLAnnContent& msgData;
public:
   ASN1C_CRLAnnContent (ASN1T_CRLAnnContent& data);
   ASN1C_CRLAnnContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_CRLAnnContent& data);
   ASN1C_CRLAnnContent (ASN1C_CRLAnnContent& 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_CRLAnnContent& getCopy (ASN1T_CRLAnnContent* pDstData = 0);
   ASN1T_CRLAnnContent* newCopy ();

   ASN1C_CRLAnnContent& operator= (ASN1C_CRLAnnContent& srcData);
   void Append (ASN1T_CertificateList * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_CRLAnnContent (ASN1CTXT* pctxt,
   ASN1T_CRLAnnContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRLAnnContent (ASN1CTXT* pctxt,
   ASN1T_CRLAnnContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CRLAnnContent (ASN1CTXT *pctxt, ASN1T_CRLAnnContent* pSrcValue, ASN1T_CRLAnnContent* pDstValue);

EXTERN void asn1Free_CRLAnnContent (ASN1CTXT *pctxt, ASN1T_CRLAnnContent* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIConfirmContent                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIConfirmContent :
   public ASN1CType
{
protected:
public:
   ASN1C_PKIConfirmContent ();
   ASN1C_PKIConfirmContent (
      ASN1MessageBufferIF& msgBuf);
   ASN1C_PKIConfirmContent (ASN1C_PKIConfirmContent& 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);


   inline ASN1C_PKIConfirmContent& operator= (ASN1C_PKIConfirmContent& srcData) {
      return *this;
   }
} ;

EXTERN int asn1E_PKIConfirmContent_ (ASN1CTXT* pctxt,
   void *pvalue, ASN1TagType tagging);
#define asn1E_PKIConfirmContent(pctxt, tagging) \
asn1E_PKIConfirmContent_(pctxt, NULL, tagging)

EXTERN int asn1D_PKIConfirmContent_ (ASN1CTXT* pctxt,
   void* pvalue, ASN1TagType tagging, int length);
#define asn1D_PKIConfirmContent(pctxt, tagging, length) \
asn1D_PKIConfirmContent_(pctxt, NULL, tagging, length)

EXTERN void asn1Copy_PKIConfirmContent_ (ASN1CTXT *pctxt, void* pSrcValue, void* pDstValue);
#define asn1Copy_PKIConfirmContent(name) \
asn1Copy_PKIConfirmContent_(name, NULL, NULL)

/**************************************************************/
/*                                                            */
/*  GenMsgContent                                             */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_GenMsgContent :
   public ASN1CSeqOfList
{
protected:
   ASN1T_GenMsgContent& msgData;
public:
   ASN1C_GenMsgContent (ASN1T_GenMsgContent& data);
   ASN1C_GenMsgContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_GenMsgContent& data);
   ASN1C_GenMsgContent (ASN1C_GenMsgContent& 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_GenMsgContent& getCopy (ASN1T_GenMsgContent* pDstData = 0);
   ASN1T_GenMsgContent* newCopy ();

   ASN1C_GenMsgContent& operator= (ASN1C_GenMsgContent& srcData);
   void Append (ASN1T_InfoTypeAndValue * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_GenMsgContent (ASN1CTXT* pctxt,
   ASN1T_GenMsgContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GenMsgContent (ASN1CTXT* pctxt,
   ASN1T_GenMsgContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_GenMsgContent (ASN1CTXT *pctxt, ASN1T_GenMsgContent* pSrcValue, ASN1T_GenMsgContent* pDstValue);

EXTERN void asn1Free_GenMsgContent (ASN1CTXT *pctxt, ASN1T_GenMsgContent* pvalue);

/**************************************************************/
/*                                                            */
/*  GenRepContent                                             */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_GenRepContent :
   public ASN1CSeqOfList
{
protected:
   ASN1T_GenRepContent& msgData;
public:
   ASN1C_GenRepContent (ASN1T_GenRepContent& data);
   ASN1C_GenRepContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_GenRepContent& data);
   ASN1C_GenRepContent (ASN1C_GenRepContent& 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_GenRepContent& getCopy (ASN1T_GenRepContent* pDstData = 0);
   ASN1T_GenRepContent* newCopy ();

   ASN1C_GenRepContent& operator= (ASN1C_GenRepContent& srcData);
   void Append (ASN1T_InfoTypeAndValue * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_GenRepContent (ASN1CTXT* pctxt,
   ASN1T_GenRepContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_GenRepContent (ASN1CTXT* pctxt,
   ASN1T_GenRepContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_GenRepContent (ASN1CTXT *pctxt, ASN1T_GenRepContent* pSrcValue, ASN1T_GenRepContent* pDstValue);

EXTERN void asn1Free_GenRepContent (ASN1CTXT *pctxt, ASN1T_GenRepContent* pvalue);

/**************************************************************/
/*                                                            */
/*  ErrorMsgContent                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ErrorMsgContent;

typedef struct EXTERN ASN1T_ErrorMsgContent : public ASN1TPDU {
   struct {
      unsigned errorCodePresent : 1;
      unsigned errorDetailsPresent : 1;
   } m;
   ASN1T_PKIStatusInfo pKIStatusInfo;
   ASN1INT errorCode;
   ASN1T_PKIFreeText errorDetails;
   ASN1T_ErrorMsgContent ();
   ASN1T_ErrorMsgContent (ASN1C_ErrorMsgContent& srcData);
   ~ASN1T_ErrorMsgContent ();
} ASN1T_ErrorMsgContent;

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

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

EXTERN int asn1E_ErrorMsgContent (ASN1CTXT* pctxt,
   ASN1T_ErrorMsgContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ErrorMsgContent (ASN1CTXT* pctxt,
   ASN1T_ErrorMsgContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ErrorMsgContent (ASN1CTXT *pctxt, ASN1T_ErrorMsgContent* pSrcValue, ASN1T_ErrorMsgContent* pDstValue);

EXTERN void asn1Free_ErrorMsgContent (ASN1CTXT *pctxt, ASN1T_ErrorMsgContent* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIBody                                                   */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PKIBody_ir                    1
#define T_PKIBody_ip                    2
#define T_PKIBody_cr                    3
#define T_PKIBody_cp                    4
#define T_PKIBody_p10cr                 5
#define T_PKIBody_popdecc               6
#define T_PKIBody_popdecr               7
#define T_PKIBody_kur                   8
#define T_PKIBody_kup                   9
#define T_PKIBody_krr                   10
#define T_PKIBody_krp                   11
#define T_PKIBody_rr                    12
#define T_PKIBody_rp                    13
#define T_PKIBody_ccr                   14
#define T_PKIBody_ccp                   15
#define T_PKIBody_ckuann                16
#define T_PKIBody_cann                  17
#define T_PKIBody_rann                  18
#define T_PKIBody_crlann                19
#define T_PKIBody_conf                  20
#define T_PKIBody_nested                21
#define T_PKIBody_genm                  22
#define T_PKIBody_genp                  23
#define T_PKIBody_error                 24

class EXTERN ASN1C_PKIBody;

typedef struct EXTERN ASN1T_PKIBody : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_CertReqMessages *ir;
      /* t = 2 */
      ASN1T_CertRepMessage *ip;
      /* t = 3 */
      ASN1T_CertReqMessages *cr;
      /* t = 4 */
      ASN1T_CertRepMessage *cp;
      /* t = 5 */
      ASN1T_CertificationRequest *p10cr;
      /* t = 6 */
      ASN1T_POPODecKeyChallContent *popdecc;
      /* t = 7 */
      ASN1T_POPODecKeyRespContent *popdecr;
      /* t = 8 */
      ASN1T_CertReqMessages *kur;
      /* t = 9 */
      ASN1T_CertRepMessage *kup;
      /* t = 10 */
      ASN1T_CertReqMessages *krr;
      /* t = 11 */
      ASN1T_KeyRecRepContent *krp;
      /* t = 12 */
      ASN1T_RevReqContent *rr;
      /* t = 13 */
      ASN1T_RevRepContent *rp;
      /* t = 14 */
      ASN1T_CertReqMessages *ccr;
      /* t = 15 */
      ASN1T_CertRepMessage *ccp;
      /* t = 16 */
      ASN1T_CAKeyUpdAnnContent *ckuann;
      /* t = 17 */
      ASN1T_CertAnnContent *cann;
      /* t = 18 */
      ASN1T_RevAnnContent *rann;
      /* t = 19 */
      ASN1T_CRLAnnContent *crlann;
      /* t = 20 */
      /* t = 21 */
      struct ASN1T_PKIMessage *nested;
      /* t = 22 */
      ASN1T_GenMsgContent *genm;
      /* t = 23 */
      ASN1T_GenRepContent *genp;
      /* t = 24 */
      ASN1T_ErrorMsgContent *error;
   } u;
   ASN1T_PKIBody () {}
   ASN1T_PKIBody (ASN1C_PKIBody& srcData);
   ~ASN1T_PKIBody ();
} ASN1T_PKIBody;

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

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

EXTERN int asn1E_PKIBody (ASN1CTXT* pctxt,
   ASN1T_PKIBody *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIBody (ASN1CTXT* pctxt,
   ASN1T_PKIBody *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIBody (ASN1CTXT *pctxt, ASN1T_PKIBody* pSrcValue, ASN1T_PKIBody* pDstValue);

EXTERN void asn1Free_PKIBody (ASN1CTXT *pctxt, ASN1T_PKIBody* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIMessage_extraCerts                                     */
/*                                                            */
/**************************************************************/

#define TV_PKIMessage_extraCerts	(TM_CTXT|TM_CONS|1)

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

class EXTERN ASN1C_PKIMessage_extraCerts :
   public ASN1CSeqOfList
{
protected:
   ASN1T_PKIMessage_extraCerts& msgData;
public:
   ASN1C_PKIMessage_extraCerts (ASN1T_PKIMessage_extraCerts& data);
   ASN1C_PKIMessage_extraCerts (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIMessage_extraCerts& data);
   ASN1C_PKIMessage_extraCerts (ASN1C_PKIMessage_extraCerts& 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_PKIMessage_extraCerts& getCopy (ASN1T_PKIMessage_extraCerts* pDstData = 0);
   ASN1T_PKIMessage_extraCerts* newCopy ();

   ASN1C_PKIMessage_extraCerts& operator= (ASN1C_PKIMessage_extraCerts& srcData);
   void Append (ASN1T_Certificate * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_PKIMessage_extraCerts (ASN1CTXT* pctxt,
   ASN1T_PKIMessage_extraCerts *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIMessage_extraCerts (ASN1CTXT* pctxt,
   ASN1T_PKIMessage_extraCerts *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIMessage_extraCerts (ASN1CTXT *pctxt, ASN1T_PKIMessage_extraCerts* pSrcValue, ASN1T_PKIMessage_extraCerts* pDstValue);

EXTERN void asn1Free_PKIMessage_extraCerts (ASN1CTXT *pctxt, ASN1T_PKIMessage_extraCerts* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIMessage                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIMessage;

typedef struct EXTERN ASN1T_PKIMessage : public ASN1TPDU {
   struct {
      unsigned protectionPresent : 1;
      unsigned extraCertsPresent : 1;
   } m;
   ASN1T_PKIHeader header;
   ASN1T_PKIBody body;
   ASN1T_PKIProtection protection;
   ASN1T_PKIMessage_extraCerts extraCerts;
   ASN1T_PKIMessage ();
   ASN1T_PKIMessage (ASN1C_PKIMessage& srcData);
   ~ASN1T_PKIMessage ();
} ASN1T_PKIMessage;

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

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

EXTERN int asn1E_PKIMessage (ASN1CTXT* pctxt,
   ASN1T_PKIMessage *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIMessage (ASN1CTXT* pctxt,
   ASN1T_PKIMessage *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_PKIMessage (ASN1CTXT *pctxt, ASN1T_PKIMessage* pSrcValue, ASN1T_PKIMessage* pDstValue);

EXTERN void asn1Free_PKIMessage (ASN1CTXT *pctxt, ASN1T_PKIMessage* pvalue);

/**************************************************************/
/*                                                            */
/*  NestedMessageContent                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_NestedMessageContent;

typedef ASN1T_PKIMessage ASN1T_NestedMessageContent;

class EXTERN ASN1C_NestedMessageContent :
   public ASN1C_PKIMessage
{
protected:
public:
   ASN1C_NestedMessageContent (ASN1T_NestedMessageContent& data);
   ASN1C_NestedMessageContent (
      ASN1MessageBufferIF& msgBuf, ASN1T_NestedMessageContent& data);
   ASN1C_NestedMessageContent (ASN1C_NestedMessageContent& 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_NestedMessageContent& getCopy (ASN1T_NestedMessageContent* pDstData = 0);
   ASN1T_NestedMessageContent* newCopy ();

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

EXTERN int asn1E_NestedMessageContent (ASN1CTXT* pctxt,
   ASN1T_NestedMessageContent *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NestedMessageContent (ASN1CTXT* pctxt,
   ASN1T_NestedMessageContent *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_NestedMessageContent (ASN1CTXT *pctxt, ASN1T_NestedMessageContent* pSrcValue, ASN1T_NestedMessageContent* pDstValue);

EXTERN void asn1Free_NestedMessageContent (ASN1CTXT *pctxt, ASN1T_NestedMessageContent* pvalue);

/**************************************************************/
/*                                                            */
/*  OOBCert                                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OOBCert;

typedef ASN1T_Certificate ASN1T_OOBCert;

class EXTERN ASN1C_OOBCert :
   public ASN1C_Certificate
{
protected:
public:
   ASN1C_OOBCert (ASN1T_OOBCert& data);
   ASN1C_OOBCert (
      ASN1MessageBufferIF& msgBuf, ASN1T_OOBCert& data);
   ASN1C_OOBCert (ASN1C_OOBCert& 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_OOBCert& getCopy (ASN1T_OOBCert* pDstData = 0);
   ASN1T_OOBCert* newCopy ();

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

EXTERN int asn1E_OOBCert (ASN1CTXT* pctxt,
   ASN1T_OOBCert *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OOBCert (ASN1CTXT* pctxt,
   ASN1T_OOBCert *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OOBCert (ASN1CTXT *pctxt, ASN1T_OOBCert* pSrcValue, ASN1T_OOBCert* pDstValue);

EXTERN void asn1Free_OOBCert (ASN1CTXT *pctxt, ASN1T_OOBCert* pvalue);

/**************************************************************/
/*                                                            */
/*  ProtectedPart                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ProtectedPart;

typedef struct EXTERN ASN1T_ProtectedPart : public ASN1TPDU {
   ASN1T_PKIHeader header;
   ASN1T_PKIBody body;
   ASN1T_ProtectedPart ();
   ASN1T_ProtectedPart (ASN1C_ProtectedPart& srcData);
   ~ASN1T_ProtectedPart ();
} ASN1T_ProtectedPart;

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

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

EXTERN int asn1E_ProtectedPart (ASN1CTXT* pctxt,
   ASN1T_ProtectedPart *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ProtectedPart (ASN1CTXT* pctxt,
   ASN1T_ProtectedPart *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ProtectedPart (ASN1CTXT *pctxt, ASN1T_ProtectedPart* pSrcValue, ASN1T_ProtectedPart* pDstValue);

EXTERN void asn1Free_ProtectedPart (ASN1CTXT *pctxt, ASN1T_ProtectedPart* pvalue);

/**************************************************************/
/*                                                            */
/*  DHBMParameter                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DHBMParameter;

typedef struct EXTERN ASN1T_DHBMParameter : public ASN1TPDU {
   ASN1T_AlgorithmIdentifier owf;
   ASN1T_AlgorithmIdentifier mac;
   ASN1T_DHBMParameter ();
   ASN1T_DHBMParameter (ASN1C_DHBMParameter& srcData);
   ~ASN1T_DHBMParameter ();
} ASN1T_DHBMParameter;

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

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

EXTERN int asn1E_DHBMParameter (ASN1CTXT* pctxt,
   ASN1T_DHBMParameter *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DHBMParameter (ASN1CTXT* pctxt,
   ASN1T_DHBMParameter *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_DHBMParameter (ASN1CTXT *pctxt, ASN1T_DHBMParameter* pSrcValue, ASN1T_DHBMParameter* pDstValue);

EXTERN void asn1Free_DHBMParameter (ASN1CTXT *pctxt, ASN1T_DHBMParameter* pvalue);

/**************************************************************/
/*                                                            */
/*  OOBCertHash                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OOBCertHash;

typedef struct EXTERN ASN1T_OOBCertHash : public ASN1TPDU {
   struct {
      unsigned hashAlgPresent : 1;
      unsigned certIdPresent : 1;
   } m;
   ASN1T_AlgorithmIdentifier hashAlg;
   ASN1T_CertId certId;
   ASN1TDynBitStr hashVal;
   ASN1T_OOBCertHash ();
   ASN1T_OOBCertHash (ASN1C_OOBCertHash& srcData);
   ~ASN1T_OOBCertHash ();
} ASN1T_OOBCertHash;

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

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

EXTERN int asn1E_OOBCertHash (ASN1CTXT* pctxt,
   ASN1T_OOBCertHash *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OOBCertHash (ASN1CTXT* pctxt,
   ASN1T_OOBCertHash *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OOBCertHash (ASN1CTXT *pctxt, ASN1T_OOBCertHash* pSrcValue, ASN1T_OOBCertHash* pDstValue);

EXTERN void asn1Free_OOBCertHash (ASN1CTXT *pctxt, ASN1T_OOBCertHash* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_it;
extern EXTERN ASN1OBJID id_it_CAProtEncCert;
extern EXTERN ASN1OBJID id_it_SignKeyPairTypes;
extern EXTERN ASN1OBJID id_it_EncKeyPairTypes;
extern EXTERN ASN1OBJID id_it_PreferredSymmAlg;
extern EXTERN ASN1OBJID id_it_CAKeyUpdateInfo;
extern EXTERN ASN1OBJID id_it_CurrentCRL;

}
#endif
