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

#include <stdio.h>
#include <stdlib.h>
#include "asn1BerCppTypes.h"
#include "asn1XerCppTypes.h"
#include "rtTable.h"
#include "ASN1CSeqOfList.h"
#include "PKIX1Explicit88.h"
#include "CertificateExtensions.h"
#include "CryptographicMessageSyntax.h"
#include "PKIX1Explicit88BaseTypes.h"
namespace asn1data {

/**************************************************************/
/*                                                            */
/*  SubsequentMessage                                         */
/*                                                            */
/**************************************************************/

struct EXTERN SubsequentMessage {
   enum Root {
      encrCert = 0,
      challengeResp = 1
   } ;
} ;

typedef ASN1UINT ASN1T_SubsequentMessage;

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

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

EXTERN int asn1E_SubsequentMessage (ASN1CTXT* pctxt,
   ASN1T_SubsequentMessage *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SubsequentMessage (ASN1CTXT* pctxt,
   ASN1T_SubsequentMessage *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SubsequentMessage
  (ASN1CTXT* pctxt, ASN1T_SubsequentMessage value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SubsequentMessage (ASN1CTXT *pctxt, ASN1T_SubsequentMessage* pSrcValue, ASN1T_SubsequentMessage* pDstValue);

/**************************************************************/
/*                                                            */
/*  RegToken                                                  */
/*                                                            */
/**************************************************************/

typedef ASN1UTF8String ASN1T_RegToken;

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

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

EXTERN int asn1E_RegToken (ASN1CTXT* pctxt,
   ASN1T_RegToken *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RegToken (ASN1CTXT* pctxt,
   ASN1T_RegToken *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_RegToken
  (ASN1CTXT* pctxt, ASN1T_RegToken value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_RegToken (ASN1CTXT *pctxt, ASN1T_RegToken* pSrcValue, ASN1T_RegToken* pDstValue);

EXTERN void asn1Free_RegToken (ASN1CTXT *pctxt, ASN1T_RegToken* pvalue);

/**************************************************************/
/*                                                            */
/*  Authenticator                                             */
/*                                                            */
/**************************************************************/

typedef ASN1UTF8String ASN1T_Authenticator;

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

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

EXTERN int asn1E_Authenticator (ASN1CTXT* pctxt,
   ASN1T_Authenticator *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Authenticator (ASN1CTXT* pctxt,
   ASN1T_Authenticator *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Authenticator
  (ASN1CTXT* pctxt, ASN1T_Authenticator value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Authenticator (ASN1CTXT *pctxt, ASN1T_Authenticator* pSrcValue, ASN1T_Authenticator* pDstValue);

EXTERN void asn1Free_Authenticator (ASN1CTXT *pctxt, ASN1T_Authenticator* pvalue);

/**************************************************************/
/*                                                            */
/*  KeyGenParameters                                          */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_KeyGenParameters;

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

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

EXTERN int asn1E_KeyGenParameters (ASN1CTXT* pctxt,
   ASN1T_KeyGenParameters *pvalue, ASN1TagType tagging);

EXTERN int asn1D_KeyGenParameters (ASN1CTXT* pctxt,
   ASN1T_KeyGenParameters *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_KeyGenParameters
  (ASN1CTXT* pctxt, ASN1T_KeyGenParameters* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_KeyGenParameters (ASN1CTXT *pctxt, ASN1T_KeyGenParameters* pSrcValue, ASN1T_KeyGenParameters* pDstValue);

EXTERN void asn1Free_KeyGenParameters (ASN1CTXT *pctxt, ASN1T_KeyGenParameters* pvalue);

/**************************************************************/
/*                                                            */
/*  OptionalValidity                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OptionalValidity;

typedef struct EXTERN ASN1T_OptionalValidity : public ASN1TPDU {
   struct {
      unsigned notBeforePresent : 1;
      unsigned notAfterPresent : 1;
   } m;
   ASN1T_Time notBefore;
   ASN1T_Time notAfter;
   ASN1T_OptionalValidity ();
   ASN1T_OptionalValidity (ASN1C_OptionalValidity& srcData);
   ~ASN1T_OptionalValidity ();
} ASN1T_OptionalValidity;

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

   class ASN1C_Time* mpNotBeforeC;
   class ASN1C_Time* mpNotAfterC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_OptionalValidity (ASN1T_OptionalValidity& data);
   ASN1C_OptionalValidity (
      ASN1MessageBufferIF& msgBuf, ASN1T_OptionalValidity& data);
   ASN1C_OptionalValidity (ASN1C_OptionalValidity& original);

   ~ASN1C_OptionalValidity();
   // 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_OptionalValidity& getCopy (ASN1T_OptionalValidity* pDstData = 0);
   ASN1T_OptionalValidity* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_OptionalValidity (ASN1CTXT* pctxt,
   ASN1T_OptionalValidity *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OptionalValidity (ASN1CTXT* pctxt,
   ASN1T_OptionalValidity *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OptionalValidity
  (ASN1CTXT* pctxt, ASN1T_OptionalValidity* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OptionalValidity (ASN1CTXT *pctxt, ASN1T_OptionalValidity* pSrcValue, ASN1T_OptionalValidity* pDstValue);

EXTERN void asn1Free_OptionalValidity (ASN1CTXT *pctxt, ASN1T_OptionalValidity* pvalue);

/**************************************************************/
/*                                                            */
/*  CertTemplate                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertTemplate;

typedef struct EXTERN ASN1T_CertTemplate : public ASN1TPDU {
   struct {
      unsigned versionPresent : 1;
      unsigned serialNumberPresent : 1;
      unsigned signingAlgPresent : 1;
      unsigned issuerPresent : 1;
      unsigned validityPresent : 1;
      unsigned subjectPresent : 1;
      unsigned publicKeyPresent : 1;
      unsigned issuerUIDPresent : 1;
      unsigned subjectUIDPresent : 1;
      unsigned extensionsPresent : 1;
   } m;
   ASN1T_Version version;
   ASN1ConstCharPtr serialNumber;
   ASN1T_AlgorithmIdentifier signingAlg;
   ASN1T_Name issuer;
   ASN1T_OptionalValidity validity;
   ASN1T_Name subject;
   ASN1T_SubjectPublicKeyInfo publicKey;
   ASN1T_UniqueIdentifier issuerUID;
   ASN1T_UniqueIdentifier subjectUID;
   ASN1T_Extensions extensions;
   ASN1T_CertTemplate ();
   ASN1T_CertTemplate (ASN1C_CertTemplate& srcData);
   ~ASN1T_CertTemplate ();
} ASN1T_CertTemplate;

class EXTERN ASN1C_CertTemplate :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertTemplate& msgData;
   struct ElementID {
      enum {
         _unknown, version, serialNumber, signingAlg, issuer, validity,
         subject, publicKey, issuerUID, subjectUID, extensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpSigningAlgC;
   class ASN1C_Name* mpIssuerC;
   class ASN1C_OptionalValidity* mpValidityC;
   class ASN1C_Name* mpSubjectC;
   class ASN1C_SubjectPublicKeyInfo* mpPublicKeyC;
   class ASN1C_Extensions* mpExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertTemplate (ASN1T_CertTemplate& data);
   ASN1C_CertTemplate (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertTemplate& data);
   ASN1C_CertTemplate (ASN1C_CertTemplate& original);

   ~ASN1C_CertTemplate();
   // 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_CertTemplate& getCopy (ASN1T_CertTemplate* pDstData = 0);
   ASN1T_CertTemplate* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertTemplate (ASN1CTXT* pctxt,
   ASN1T_CertTemplate *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertTemplate (ASN1CTXT* pctxt,
   ASN1T_CertTemplate *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertTemplate
  (ASN1CTXT* pctxt, ASN1T_CertTemplate* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertTemplate (ASN1CTXT *pctxt, ASN1T_CertTemplate* pSrcValue, ASN1T_CertTemplate* pDstValue);

EXTERN void asn1Free_CertTemplate (ASN1CTXT *pctxt, ASN1T_CertTemplate* pvalue);

/**************************************************************/
/*                                                            */
/*  Controls                                                  */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_Controls :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Controls& msgData;
   ASN1T_AttributeTypeAndValue *mpElement;
   class ASN1C_AttributeTypeAndValue* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_Controls (ASN1T_Controls& data);
   ASN1C_Controls (
      ASN1MessageBufferIF& msgBuf, ASN1T_Controls& data);
   ASN1C_Controls (ASN1C_Controls& original);

   ~ASN1C_Controls();
   // 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_Controls& getCopy (ASN1T_Controls* pDstData = 0);
   ASN1T_Controls* newCopy ();

   ASN1C_Controls& operator= (ASN1C_Controls& srcData);
   void Append (ASN1T_AttributeTypeAndValue * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_Controls (ASN1CTXT* pctxt,
   ASN1T_Controls *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Controls (ASN1CTXT* pctxt,
   ASN1T_Controls *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Controls
  (ASN1CTXT* pctxt, ASN1T_Controls* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Controls (ASN1CTXT *pctxt, ASN1T_Controls* pSrcValue, ASN1T_Controls* pDstValue);

EXTERN void asn1Free_Controls (ASN1CTXT *pctxt, ASN1T_Controls* pvalue);

/**************************************************************/
/*                                                            */
/*  CertRequest                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertRequest;

typedef struct EXTERN ASN1T_CertRequest : public ASN1TPDU {
   struct {
      unsigned controlsPresent : 1;
   } m;
   ASN1INT certReqId;
   ASN1T_CertTemplate certTemplate;
   ASN1T_Controls controls;
   ASN1T_CertRequest ();
   ASN1T_CertRequest (ASN1C_CertRequest& srcData);
   ~ASN1T_CertRequest ();
} ASN1T_CertRequest;

class EXTERN ASN1C_CertRequest :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertRequest& msgData;
   struct ElementID {
      enum {
         _unknown, certReqId, certTemplate, controls
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CertTemplate* mpCertTemplateC;
   class ASN1C_Controls* mpControlsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertRequest (ASN1T_CertRequest& data);
   ASN1C_CertRequest (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertRequest& data);
   ASN1C_CertRequest (ASN1C_CertRequest& original);

   ~ASN1C_CertRequest();
   // 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_CertRequest& getCopy (ASN1T_CertRequest* pDstData = 0);
   ASN1T_CertRequest* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertRequest (ASN1CTXT* pctxt,
   ASN1T_CertRequest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertRequest (ASN1CTXT* pctxt,
   ASN1T_CertRequest *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertRequest
  (ASN1CTXT* pctxt, ASN1T_CertRequest* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertRequest (ASN1CTXT *pctxt, ASN1T_CertRequest* pSrcValue, ASN1T_CertRequest* pDstValue);

EXTERN void asn1Free_CertRequest (ASN1CTXT *pctxt, ASN1T_CertRequest* pvalue);

/**************************************************************/
/*                                                            */
/*  PKMACValue                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKMACValue;

typedef struct EXTERN ASN1T_PKMACValue : public ASN1TPDU {
   ASN1T_AlgorithmIdentifier algId;
   ASN1TDynBitStr value;
   ASN1T_PKMACValue ();
   ASN1T_PKMACValue (ASN1C_PKMACValue& srcData);
   ~ASN1T_PKMACValue ();
} ASN1T_PKMACValue;

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

   class ASN1C_AlgorithmIdentifier* mpAlgIdC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PKMACValue (ASN1T_PKMACValue& data);
   ASN1C_PKMACValue (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKMACValue& data);
   ASN1C_PKMACValue (ASN1C_PKMACValue& original);

   ~ASN1C_PKMACValue();
   // 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_PKMACValue& getCopy (ASN1T_PKMACValue* pDstData = 0);
   ASN1T_PKMACValue* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PKMACValue (ASN1CTXT* pctxt,
   ASN1T_PKMACValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKMACValue (ASN1CTXT* pctxt,
   ASN1T_PKMACValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PKMACValue
  (ASN1CTXT* pctxt, ASN1T_PKMACValue* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PKMACValue (ASN1CTXT *pctxt, ASN1T_PKMACValue* pSrcValue, ASN1T_PKMACValue* pDstValue);

EXTERN void asn1Free_PKMACValue (ASN1CTXT *pctxt, ASN1T_PKMACValue* pvalue);

/**************************************************************/
/*                                                            */
/*  POPOSigningKeyInput_authInfo                              */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_POPOSigningKeyInput_authInfo_publicKeyMAC 1
#define T_POPOSigningKeyInput_authInfo_sender 2

class EXTERN ASN1C_POPOSigningKeyInput_authInfo;

typedef struct EXTERN ASN1T_POPOSigningKeyInput_authInfo : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_PKMACValue *publicKeyMAC;
      /* t = 2 */
      ASN1T_GeneralName *sender;
   } u;
   ASN1T_POPOSigningKeyInput_authInfo () {}
   ASN1T_POPOSigningKeyInput_authInfo (ASN1C_POPOSigningKeyInput_authInfo& srcData);
   ~ASN1T_POPOSigningKeyInput_authInfo ();
} ASN1T_POPOSigningKeyInput_authInfo;

class EXTERN ASN1C_POPOSigningKeyInput_authInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_POPOSigningKeyInput_authInfo& msgData;
   struct ElementID {
      enum {
         _unknown, publicKeyMAC, sender
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PKMACValue* mpPublicKeyMACC;
   class ASN1C_GeneralName* mpSenderC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_POPOSigningKeyInput_authInfo (ASN1T_POPOSigningKeyInput_authInfo& data);
   ASN1C_POPOSigningKeyInput_authInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_POPOSigningKeyInput_authInfo& data);
   ASN1C_POPOSigningKeyInput_authInfo (ASN1C_POPOSigningKeyInput_authInfo& original);

   ~ASN1C_POPOSigningKeyInput_authInfo();
   // 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_POPOSigningKeyInput_authInfo& getCopy (ASN1T_POPOSigningKeyInput_authInfo* pDstData = 0);
   ASN1T_POPOSigningKeyInput_authInfo* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_POPOSigningKeyInput_authInfo (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKeyInput_authInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPOSigningKeyInput_authInfo (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKeyInput_authInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_POPOSigningKeyInput_authInfo
  (ASN1CTXT* pctxt, ASN1T_POPOSigningKeyInput_authInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_POPOSigningKeyInput_authInfo (ASN1CTXT *pctxt, ASN1T_POPOSigningKeyInput_authInfo* pSrcValue, ASN1T_POPOSigningKeyInput_authInfo* pDstValue);

EXTERN void asn1Free_POPOSigningKeyInput_authInfo (ASN1CTXT *pctxt, ASN1T_POPOSigningKeyInput_authInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  POPOSigningKeyInput                                       */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_POPOSigningKeyInput;

typedef struct EXTERN ASN1T_POPOSigningKeyInput : public ASN1TPDU {
   ASN1T_POPOSigningKeyInput_authInfo authInfo;
   ASN1T_SubjectPublicKeyInfo publicKey;
   ASN1T_POPOSigningKeyInput ();
   ASN1T_POPOSigningKeyInput (ASN1C_POPOSigningKeyInput& srcData);
   ~ASN1T_POPOSigningKeyInput ();
} ASN1T_POPOSigningKeyInput;

class EXTERN ASN1C_POPOSigningKeyInput :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_POPOSigningKeyInput& msgData;
   struct ElementID {
      enum {
         _unknown, authInfo, publicKey
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_POPOSigningKeyInput_authInfo* mpAuthInfoC;
   class ASN1C_SubjectPublicKeyInfo* mpPublicKeyC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_POPOSigningKeyInput (ASN1T_POPOSigningKeyInput& data);
   ASN1C_POPOSigningKeyInput (
      ASN1MessageBufferIF& msgBuf, ASN1T_POPOSigningKeyInput& data);
   ASN1C_POPOSigningKeyInput (ASN1C_POPOSigningKeyInput& original);

   ~ASN1C_POPOSigningKeyInput();
   // 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_POPOSigningKeyInput& getCopy (ASN1T_POPOSigningKeyInput* pDstData = 0);
   ASN1T_POPOSigningKeyInput* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_POPOSigningKeyInput (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKeyInput *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPOSigningKeyInput (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKeyInput *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_POPOSigningKeyInput
  (ASN1CTXT* pctxt, ASN1T_POPOSigningKeyInput* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_POPOSigningKeyInput (ASN1CTXT *pctxt, ASN1T_POPOSigningKeyInput* pSrcValue, ASN1T_POPOSigningKeyInput* pDstValue);

EXTERN void asn1Free_POPOSigningKeyInput (ASN1CTXT *pctxt, ASN1T_POPOSigningKeyInput* pvalue);

/**************************************************************/
/*                                                            */
/*  POPOSigningKey                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_POPOSigningKey;

typedef struct EXTERN ASN1T_POPOSigningKey : public ASN1TPDU {
   struct {
      unsigned poposkInputPresent : 1;
   } m;
   ASN1T_POPOSigningKeyInput poposkInput;
   ASN1T_AlgorithmIdentifier algorithmIdentifier;
   ASN1TDynBitStr signature;
   ASN1T_POPOSigningKey ();
   ASN1T_POPOSigningKey (ASN1C_POPOSigningKey& srcData);
   ~ASN1T_POPOSigningKey ();
} ASN1T_POPOSigningKey;

class EXTERN ASN1C_POPOSigningKey :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_POPOSigningKey& msgData;
   struct ElementID {
      enum {
         _unknown, poposkInput, algorithmIdentifier, signature
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_POPOSigningKeyInput* mpPoposkInputC;
   class ASN1C_AlgorithmIdentifier* mpAlgorithmIdentifierC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_POPOSigningKey (ASN1T_POPOSigningKey& data);
   ASN1C_POPOSigningKey (
      ASN1MessageBufferIF& msgBuf, ASN1T_POPOSigningKey& data);
   ASN1C_POPOSigningKey (ASN1C_POPOSigningKey& original);

   ~ASN1C_POPOSigningKey();
   // 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_POPOSigningKey& getCopy (ASN1T_POPOSigningKey* pDstData = 0);
   ASN1T_POPOSigningKey* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_POPOSigningKey (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKey *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPOSigningKey (ASN1CTXT* pctxt,
   ASN1T_POPOSigningKey *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_POPOSigningKey
  (ASN1CTXT* pctxt, ASN1T_POPOSigningKey* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_POPOSigningKey (ASN1CTXT *pctxt, ASN1T_POPOSigningKey* pSrcValue, ASN1T_POPOSigningKey* pDstValue);

EXTERN void asn1Free_POPOSigningKey (ASN1CTXT *pctxt, ASN1T_POPOSigningKey* pvalue);

/**************************************************************/
/*                                                            */
/*  POPOPrivKey                                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_POPOPrivKey_thisMessage       1
#define T_POPOPrivKey_subsequentMessage 2
#define T_POPOPrivKey_dhMAC             3

class EXTERN ASN1C_POPOPrivKey;

typedef struct EXTERN ASN1T_POPOPrivKey : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1TDynBitStr *thisMessage;
      /* t = 2 */
      ASN1T_SubsequentMessage subsequentMessage;
      /* t = 3 */
      ASN1TDynBitStr *dhMAC;
   } u;
   ASN1T_POPOPrivKey () {}
   ASN1T_POPOPrivKey (ASN1C_POPOPrivKey& srcData);
   ~ASN1T_POPOPrivKey ();
} ASN1T_POPOPrivKey;

class EXTERN ASN1C_POPOPrivKey :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_POPOPrivKey& msgData;
   struct ElementID {
      enum {
         _unknown, thisMessage, subsequentMessage, dhMAC
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

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

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_POPOPrivKey (ASN1CTXT* pctxt,
   ASN1T_POPOPrivKey *pvalue, ASN1TagType tagging);

EXTERN int asn1D_POPOPrivKey (ASN1CTXT* pctxt,
   ASN1T_POPOPrivKey *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_POPOPrivKey
  (ASN1CTXT* pctxt, ASN1T_POPOPrivKey* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_POPOPrivKey (ASN1CTXT *pctxt, ASN1T_POPOPrivKey* pSrcValue, ASN1T_POPOPrivKey* pDstValue);

EXTERN void asn1Free_POPOPrivKey (ASN1CTXT *pctxt, ASN1T_POPOPrivKey* pvalue);

/**************************************************************/
/*                                                            */
/*  ProofOfPossession                                         */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_ProofOfPossession_raVerified  1
#define T_ProofOfPossession_signature   2
#define T_ProofOfPossession_keyEncipherment 3
#define T_ProofOfPossession_keyAgreement 4

class EXTERN ASN1C_ProofOfPossession;

typedef struct EXTERN ASN1T_ProofOfPossession : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      /* t = 2 */
      ASN1T_POPOSigningKey *signature;
      /* t = 3 */
      ASN1T_POPOPrivKey *keyEncipherment;
      /* t = 4 */
      ASN1T_POPOPrivKey *keyAgreement;
   } u;
   ASN1T_ProofOfPossession () {}
   ASN1T_ProofOfPossession (ASN1C_ProofOfPossession& srcData);
   ~ASN1T_ProofOfPossession ();
} ASN1T_ProofOfPossession;

class EXTERN ASN1C_ProofOfPossession :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_ProofOfPossession& msgData;
   struct ElementID {
      enum {
         _unknown, raVerified, signature, keyEncipherment, keyAgreement
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_POPOSigningKey* mpSignatureC;
   class ASN1C_POPOPrivKey* mpKeyEnciphermentC;
   class ASN1C_POPOPrivKey* mpKeyAgreementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_ProofOfPossession (ASN1T_ProofOfPossession& data);
   ASN1C_ProofOfPossession (
      ASN1MessageBufferIF& msgBuf, ASN1T_ProofOfPossession& data);
   ASN1C_ProofOfPossession (ASN1C_ProofOfPossession& original);

   ~ASN1C_ProofOfPossession();
   // 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_ProofOfPossession& getCopy (ASN1T_ProofOfPossession* pDstData = 0);
   ASN1T_ProofOfPossession* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_ProofOfPossession (ASN1CTXT* pctxt,
   ASN1T_ProofOfPossession *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ProofOfPossession (ASN1CTXT* pctxt,
   ASN1T_ProofOfPossession *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ProofOfPossession
  (ASN1CTXT* pctxt, ASN1T_ProofOfPossession* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ProofOfPossession (ASN1CTXT *pctxt, ASN1T_ProofOfPossession* pSrcValue, ASN1T_ProofOfPossession* pDstValue);

EXTERN void asn1Free_ProofOfPossession (ASN1CTXT *pctxt, ASN1T_ProofOfPossession* pvalue);

/**************************************************************/
/*                                                            */
/*  CertReqMsg_regInfo                                        */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_CertReqMsg_regInfo :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertReqMsg_regInfo& msgData;
   ASN1T_AttributeTypeAndValue *mpElement;
   class ASN1C_AttributeTypeAndValue* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_CertReqMsg_regInfo (ASN1T_CertReqMsg_regInfo& data);
   ASN1C_CertReqMsg_regInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertReqMsg_regInfo& data);
   ASN1C_CertReqMsg_regInfo (ASN1C_CertReqMsg_regInfo& original);

   ~ASN1C_CertReqMsg_regInfo();
   // 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_CertReqMsg_regInfo& getCopy (ASN1T_CertReqMsg_regInfo* pDstData = 0);
   ASN1T_CertReqMsg_regInfo* newCopy ();

   ASN1C_CertReqMsg_regInfo& operator= (ASN1C_CertReqMsg_regInfo& srcData);
   void Append (ASN1T_AttributeTypeAndValue * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertReqMsg_regInfo (ASN1CTXT* pctxt,
   ASN1T_CertReqMsg_regInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertReqMsg_regInfo (ASN1CTXT* pctxt,
   ASN1T_CertReqMsg_regInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertReqMsg_regInfo
  (ASN1CTXT* pctxt, ASN1T_CertReqMsg_regInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertReqMsg_regInfo (ASN1CTXT *pctxt, ASN1T_CertReqMsg_regInfo* pSrcValue, ASN1T_CertReqMsg_regInfo* pDstValue);

EXTERN void asn1Free_CertReqMsg_regInfo (ASN1CTXT *pctxt, ASN1T_CertReqMsg_regInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  CertReqMsg                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertReqMsg;

typedef struct EXTERN ASN1T_CertReqMsg : public ASN1TPDU {
   struct {
      unsigned popPresent : 1;
      unsigned regInfoPresent : 1;
   } m;
   ASN1T_CertRequest certReq;
   ASN1T_ProofOfPossession pop;
   ASN1T_CertReqMsg_regInfo regInfo;
   ASN1T_CertReqMsg ();
   ASN1T_CertReqMsg (ASN1C_CertReqMsg& srcData);
   ~ASN1T_CertReqMsg ();
} ASN1T_CertReqMsg;

class EXTERN ASN1C_CertReqMsg :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertReqMsg& msgData;
   struct ElementID {
      enum {
         _unknown, certReq, pop, regInfo
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CertRequest* mpCertReqC;
   class ASN1C_ProofOfPossession* mpPopC;
   class ASN1C_CertReqMsg_regInfo* mpRegInfoC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_CertReqMsg (ASN1T_CertReqMsg& data);
   ASN1C_CertReqMsg (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertReqMsg& data);
   ASN1C_CertReqMsg (ASN1C_CertReqMsg& original);

   ~ASN1C_CertReqMsg();
   // 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_CertReqMsg& getCopy (ASN1T_CertReqMsg* pDstData = 0);
   ASN1T_CertReqMsg* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertReqMsg (ASN1CTXT* pctxt,
   ASN1T_CertReqMsg *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertReqMsg (ASN1CTXT* pctxt,
   ASN1T_CertReqMsg *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertReqMsg
  (ASN1CTXT* pctxt, ASN1T_CertReqMsg* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertReqMsg (ASN1CTXT *pctxt, ASN1T_CertReqMsg* pSrcValue, ASN1T_CertReqMsg* pDstValue);

EXTERN void asn1Free_CertReqMsg (ASN1CTXT *pctxt, ASN1T_CertReqMsg* pvalue);

/**************************************************************/
/*                                                            */
/*  CertReqMessages                                           */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_CertReqMessages :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertReqMessages& msgData;
   ASN1T_CertReqMsg *mpElement;
   class ASN1C_CertReqMsg* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_CertReqMessages (ASN1T_CertReqMessages& data);
   ASN1C_CertReqMessages (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertReqMessages& data);
   ASN1C_CertReqMessages (ASN1C_CertReqMessages& original);

   ~ASN1C_CertReqMessages();
   // 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_CertReqMessages& getCopy (ASN1T_CertReqMessages* pDstData = 0);
   ASN1T_CertReqMessages* newCopy ();

   ASN1C_CertReqMessages& operator= (ASN1C_CertReqMessages& srcData);
   void Append (ASN1T_CertReqMsg * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertReqMessages (ASN1CTXT* pctxt,
   ASN1T_CertReqMessages *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertReqMessages (ASN1CTXT* pctxt,
   ASN1T_CertReqMessages *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertReqMessages
  (ASN1CTXT* pctxt, ASN1T_CertReqMessages* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertReqMessages (ASN1CTXT *pctxt, ASN1T_CertReqMessages* pSrcValue, ASN1T_CertReqMessages* pDstValue);

EXTERN void asn1Free_CertReqMessages (ASN1CTXT *pctxt, ASN1T_CertReqMessages* pvalue);

/**************************************************************/
/*                                                            */
/*  EncryptedValue                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_EncryptedValue;

typedef struct EXTERN ASN1T_EncryptedValue : public ASN1TPDU {
   struct {
      unsigned intendedAlgPresent : 1;
      unsigned symmAlgPresent : 1;
      unsigned encSymmKeyPresent : 1;
      unsigned keyAlgPresent : 1;
      unsigned valueHintPresent : 1;
   } m;
   ASN1T_AlgorithmIdentifier intendedAlg;
   ASN1T_AlgorithmIdentifier symmAlg;
   ASN1TDynBitStr encSymmKey;
   ASN1T_AlgorithmIdentifier keyAlg;
   ASN1TDynOctStr valueHint;
   ASN1TDynBitStr encValue;
   ASN1T_EncryptedValue ();
   ASN1T_EncryptedValue (ASN1C_EncryptedValue& srcData);
   ~ASN1T_EncryptedValue ();
} ASN1T_EncryptedValue;

class EXTERN ASN1C_EncryptedValue :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EncryptedValue& msgData;
   struct ElementID {
      enum {
         _unknown, intendedAlg, symmAlg, encSymmKey, keyAlg, valueHint,
         encValue
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpIntendedAlgC;
   class ASN1C_AlgorithmIdentifier* mpSymmAlgC;
   class ASN1C_AlgorithmIdentifier* mpKeyAlgC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_EncryptedValue (ASN1T_EncryptedValue& data);
   ASN1C_EncryptedValue (
      ASN1MessageBufferIF& msgBuf, ASN1T_EncryptedValue& data);
   ASN1C_EncryptedValue (ASN1C_EncryptedValue& original);

   ~ASN1C_EncryptedValue();
   // 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_EncryptedValue& getCopy (ASN1T_EncryptedValue* pDstData = 0);
   ASN1T_EncryptedValue* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_EncryptedValue (ASN1CTXT* pctxt,
   ASN1T_EncryptedValue *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EncryptedValue (ASN1CTXT* pctxt,
   ASN1T_EncryptedValue *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EncryptedValue
  (ASN1CTXT* pctxt, ASN1T_EncryptedValue* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EncryptedValue (ASN1CTXT *pctxt, ASN1T_EncryptedValue* pSrcValue, ASN1T_EncryptedValue* pDstValue);

EXTERN void asn1Free_EncryptedValue (ASN1CTXT *pctxt, ASN1T_EncryptedValue* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIPublicationInfo_action                                 */
/*                                                            */
/**************************************************************/

struct EXTERN PKIPublicationInfo_action {
   enum Root {
      dontPublish = 0,
      pleasePublish = 1
   } ;
} ;

typedef ASN1UINT ASN1T_PKIPublicationInfo_action;

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

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

EXTERN int asn1E_PKIPublicationInfo_action (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo_action *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIPublicationInfo_action (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo_action *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PKIPublicationInfo_action
  (ASN1CTXT* pctxt, ASN1T_PKIPublicationInfo_action value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PKIPublicationInfo_action (ASN1CTXT *pctxt, ASN1T_PKIPublicationInfo_action* pSrcValue, ASN1T_PKIPublicationInfo_action* pDstValue);

/**************************************************************/
/*                                                            */
/*  SinglePubInfo_pubMethod                                   */
/*                                                            */
/**************************************************************/

struct EXTERN SinglePubInfo_pubMethod {
   enum Root {
      dontCare = 0,
      x500 = 1,
      web = 2,
      ldap = 3
   } ;
} ;

typedef ASN1UINT ASN1T_SinglePubInfo_pubMethod;

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

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

EXTERN int asn1E_SinglePubInfo_pubMethod (ASN1CTXT* pctxt,
   ASN1T_SinglePubInfo_pubMethod *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SinglePubInfo_pubMethod (ASN1CTXT* pctxt,
   ASN1T_SinglePubInfo_pubMethod *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SinglePubInfo_pubMethod
  (ASN1CTXT* pctxt, ASN1T_SinglePubInfo_pubMethod value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SinglePubInfo_pubMethod (ASN1CTXT *pctxt, ASN1T_SinglePubInfo_pubMethod* pSrcValue, ASN1T_SinglePubInfo_pubMethod* pDstValue);

/**************************************************************/
/*                                                            */
/*  SinglePubInfo                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SinglePubInfo;

typedef struct EXTERN ASN1T_SinglePubInfo : public ASN1TPDU {
   struct {
      unsigned pubLocationPresent : 1;
   } m;
   ASN1T_SinglePubInfo_pubMethod pubMethod;
   ASN1T_GeneralName pubLocation;
   ASN1T_SinglePubInfo ();
   ASN1T_SinglePubInfo (ASN1C_SinglePubInfo& srcData);
   ~ASN1T_SinglePubInfo ();
} ASN1T_SinglePubInfo;

class EXTERN ASN1C_SinglePubInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_SinglePubInfo& msgData;
   struct ElementID {
      enum {
         _unknown, pubMethod, pubLocation
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_GeneralName* mpPubLocationC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_SinglePubInfo (ASN1T_SinglePubInfo& data);
   ASN1C_SinglePubInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_SinglePubInfo& data);
   ASN1C_SinglePubInfo (ASN1C_SinglePubInfo& original);

   ~ASN1C_SinglePubInfo();
   // 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_SinglePubInfo& getCopy (ASN1T_SinglePubInfo* pDstData = 0);
   ASN1T_SinglePubInfo* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_SinglePubInfo (ASN1CTXT* pctxt,
   ASN1T_SinglePubInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SinglePubInfo (ASN1CTXT* pctxt,
   ASN1T_SinglePubInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_SinglePubInfo
  (ASN1CTXT* pctxt, ASN1T_SinglePubInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_SinglePubInfo (ASN1CTXT *pctxt, ASN1T_SinglePubInfo* pSrcValue, ASN1T_SinglePubInfo* pDstValue);

EXTERN void asn1Free_SinglePubInfo (ASN1CTXT *pctxt, ASN1T_SinglePubInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIPublicationInfo_pubInfos                               */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_PKIPublicationInfo_pubInfos :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PKIPublicationInfo_pubInfos& msgData;
   ASN1T_SinglePubInfo *mpElement;
   class ASN1C_SinglePubInfo* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_PKIPublicationInfo_pubInfos (ASN1T_PKIPublicationInfo_pubInfos& data);
   ASN1C_PKIPublicationInfo_pubInfos (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIPublicationInfo_pubInfos& data);
   ASN1C_PKIPublicationInfo_pubInfos (ASN1C_PKIPublicationInfo_pubInfos& original);

   ~ASN1C_PKIPublicationInfo_pubInfos();
   // 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_PKIPublicationInfo_pubInfos& getCopy (ASN1T_PKIPublicationInfo_pubInfos* pDstData = 0);
   ASN1T_PKIPublicationInfo_pubInfos* newCopy ();

   ASN1C_PKIPublicationInfo_pubInfos& operator= (ASN1C_PKIPublicationInfo_pubInfos& srcData);
   void Append (ASN1T_SinglePubInfo * elem) {
      append ((void*)elem);
   }

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PKIPublicationInfo_pubInfos (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo_pubInfos *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIPublicationInfo_pubInfos (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo_pubInfos *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PKIPublicationInfo_pubInfos
  (ASN1CTXT* pctxt, ASN1T_PKIPublicationInfo_pubInfos* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PKIPublicationInfo_pubInfos (ASN1CTXT *pctxt, ASN1T_PKIPublicationInfo_pubInfos* pSrcValue, ASN1T_PKIPublicationInfo_pubInfos* pDstValue);

EXTERN void asn1Free_PKIPublicationInfo_pubInfos (ASN1CTXT *pctxt, ASN1T_PKIPublicationInfo_pubInfos* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIPublicationInfo                                        */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PKIPublicationInfo;

typedef struct EXTERN ASN1T_PKIPublicationInfo : public ASN1TPDU {
   struct {
      unsigned pubInfosPresent : 1;
   } m;
   ASN1T_PKIPublicationInfo_action action;
   ASN1T_PKIPublicationInfo_pubInfos pubInfos;
   ASN1T_PKIPublicationInfo ();
   ASN1T_PKIPublicationInfo (ASN1C_PKIPublicationInfo& srcData);
   ~ASN1T_PKIPublicationInfo ();
} ASN1T_PKIPublicationInfo;

class EXTERN ASN1C_PKIPublicationInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PKIPublicationInfo& msgData;
   struct ElementID {
      enum {
         _unknown, action, pubInfos
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PKIPublicationInfo_pubInfos* mpPubInfosC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PKIPublicationInfo (ASN1T_PKIPublicationInfo& data);
   ASN1C_PKIPublicationInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIPublicationInfo& data);
   ASN1C_PKIPublicationInfo (ASN1C_PKIPublicationInfo& original);

   ~ASN1C_PKIPublicationInfo();
   // 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_PKIPublicationInfo& getCopy (ASN1T_PKIPublicationInfo* pDstData = 0);
   ASN1T_PKIPublicationInfo* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PKIPublicationInfo (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIPublicationInfo (ASN1CTXT* pctxt,
   ASN1T_PKIPublicationInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PKIPublicationInfo
  (ASN1CTXT* pctxt, ASN1T_PKIPublicationInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PKIPublicationInfo (ASN1CTXT *pctxt, ASN1T_PKIPublicationInfo* pSrcValue, ASN1T_PKIPublicationInfo* pDstValue);

EXTERN void asn1Free_PKIPublicationInfo (ASN1CTXT *pctxt, ASN1T_PKIPublicationInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  CertId                                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertId;

typedef struct EXTERN ASN1T_CertId : public ASN1TPDU {
   ASN1T_GeneralName issuer;
   ASN1ConstCharPtr serialNumber;
   ASN1T_CertId ();
   ASN1T_CertId (ASN1C_CertId& srcData);
   ~ASN1T_CertId ();
} ASN1T_CertId;

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

   class ASN1C_GeneralName* mpIssuerC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_CertId (ASN1T_CertId& data);
   ASN1C_CertId (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertId& data);
   ASN1C_CertId (ASN1C_CertId& original);

   ~ASN1C_CertId();
   // 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_CertId& getCopy (ASN1T_CertId* pDstData = 0);
   ASN1T_CertId* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_CertId (ASN1CTXT* pctxt,
   ASN1T_CertId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertId (ASN1CTXT* pctxt,
   ASN1T_CertId *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertId
  (ASN1CTXT* pctxt, ASN1T_CertId* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertId (ASN1CTXT *pctxt, ASN1T_CertId* pSrcValue, ASN1T_CertId* pDstValue);

EXTERN void asn1Free_CertId (ASN1CTXT *pctxt, ASN1T_CertId* pvalue);

/**************************************************************/
/*                                                            */
/*  OldCertId                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OldCertId;

typedef ASN1T_CertId ASN1T_OldCertId;

class EXTERN ASN1C_OldCertId :
   public ASN1C_CertId
{
protected:
public:
   ASN1C_OldCertId (ASN1T_OldCertId& data);
   ASN1C_OldCertId (
      ASN1MessageBufferIF& msgBuf, ASN1T_OldCertId& data);
   ASN1C_OldCertId (ASN1C_OldCertId& 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_OldCertId& getCopy (ASN1T_OldCertId* pDstData = 0);
   ASN1T_OldCertId* newCopy ();

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

EXTERN int asn1E_OldCertId (ASN1CTXT* pctxt,
   ASN1T_OldCertId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OldCertId (ASN1CTXT* pctxt,
   ASN1T_OldCertId *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_OldCertId
  (ASN1CTXT* pctxt, ASN1T_OldCertId* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_OldCertId (ASN1CTXT *pctxt, ASN1T_OldCertId* pSrcValue, ASN1T_OldCertId* pDstValue);

EXTERN void asn1Free_OldCertId (ASN1CTXT *pctxt, ASN1T_OldCertId* pvalue);

/**************************************************************/
/*                                                            */
/*  ProtocolEncrKey                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ProtocolEncrKey;

typedef ASN1T_SubjectPublicKeyInfo ASN1T_ProtocolEncrKey;

class EXTERN ASN1C_ProtocolEncrKey :
   public ASN1C_SubjectPublicKeyInfo
{
protected:
public:
   ASN1C_ProtocolEncrKey (ASN1T_ProtocolEncrKey& data);
   ASN1C_ProtocolEncrKey (
      ASN1MessageBufferIF& msgBuf, ASN1T_ProtocolEncrKey& data);
   ASN1C_ProtocolEncrKey (ASN1C_ProtocolEncrKey& 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_ProtocolEncrKey& getCopy (ASN1T_ProtocolEncrKey* pDstData = 0);
   ASN1T_ProtocolEncrKey* newCopy ();

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

EXTERN int asn1E_ProtocolEncrKey (ASN1CTXT* pctxt,
   ASN1T_ProtocolEncrKey *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ProtocolEncrKey (ASN1CTXT* pctxt,
   ASN1T_ProtocolEncrKey *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ProtocolEncrKey
  (ASN1CTXT* pctxt, ASN1T_ProtocolEncrKey* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ProtocolEncrKey (ASN1CTXT *pctxt, ASN1T_ProtocolEncrKey* pSrcValue, ASN1T_ProtocolEncrKey* pDstValue);

EXTERN void asn1Free_ProtocolEncrKey (ASN1CTXT *pctxt, ASN1T_ProtocolEncrKey* pvalue);

/**************************************************************/
/*                                                            */
/*  UTF8Pairs                                                 */
/*                                                            */
/**************************************************************/

typedef ASN1UTF8String ASN1T_UTF8Pairs;

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

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

EXTERN int asn1E_UTF8Pairs (ASN1CTXT* pctxt,
   ASN1T_UTF8Pairs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_UTF8Pairs (ASN1CTXT* pctxt,
   ASN1T_UTF8Pairs *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_UTF8Pairs
  (ASN1CTXT* pctxt, ASN1T_UTF8Pairs value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_UTF8Pairs (ASN1CTXT *pctxt, ASN1T_UTF8Pairs* pSrcValue, ASN1T_UTF8Pairs* pDstValue);

EXTERN void asn1Free_UTF8Pairs (ASN1CTXT *pctxt, ASN1T_UTF8Pairs* pvalue);

/**************************************************************/
/*                                                            */
/*  CertReq                                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertReq;

typedef ASN1T_CertRequest ASN1T_CertReq;

class EXTERN ASN1C_CertReq :
   public ASN1C_CertRequest
{
protected:
public:
   ASN1C_CertReq (ASN1T_CertReq& data);
   ASN1C_CertReq (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertReq& data);
   ASN1C_CertReq (ASN1C_CertReq& 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_CertReq& getCopy (ASN1T_CertReq* pDstData = 0);
   ASN1T_CertReq* newCopy ();

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

EXTERN int asn1E_CertReq (ASN1CTXT* pctxt,
   ASN1T_CertReq *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertReq (ASN1CTXT* pctxt,
   ASN1T_CertReq *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertReq
  (ASN1CTXT* pctxt, ASN1T_CertReq* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertReq (ASN1CTXT *pctxt, ASN1T_CertReq* pSrcValue, ASN1T_CertReq* pDstValue);

EXTERN void asn1Free_CertReq (ASN1CTXT *pctxt, ASN1T_CertReq* pvalue);

/**************************************************************/
/*                                                            */
/*  PBMParameter                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PBMParameter;

typedef struct EXTERN ASN1T_PBMParameter : public ASN1TPDU {
   ASN1TDynOctStr salt;
   ASN1T_AlgorithmIdentifier owf;
   ASN1INT iterationCount;
   ASN1T_AlgorithmIdentifier mac;
   ASN1T_PBMParameter ();
   ASN1T_PBMParameter (ASN1C_PBMParameter& srcData);
   ~ASN1T_PBMParameter ();
} ASN1T_PBMParameter;

class EXTERN ASN1C_PBMParameter :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PBMParameter& msgData;
   struct ElementID {
      enum {
         _unknown, salt, owf, iterationCount, mac
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_AlgorithmIdentifier* mpOwfC;
   class ASN1C_AlgorithmIdentifier* mpMacC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PBMParameter (ASN1T_PBMParameter& data);
   ASN1C_PBMParameter (
      ASN1MessageBufferIF& msgBuf, ASN1T_PBMParameter& data);
   ASN1C_PBMParameter (ASN1C_PBMParameter& original);

   ~ASN1C_PBMParameter();
   // 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_PBMParameter& getCopy (ASN1T_PBMParameter* pDstData = 0);
   ASN1T_PBMParameter* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PBMParameter (ASN1CTXT* pctxt,
   ASN1T_PBMParameter *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PBMParameter (ASN1CTXT* pctxt,
   ASN1T_PBMParameter *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PBMParameter
  (ASN1CTXT* pctxt, ASN1T_PBMParameter* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PBMParameter (ASN1CTXT *pctxt, ASN1T_PBMParameter* pSrcValue, ASN1T_PBMParameter* pDstValue);

EXTERN void asn1Free_PBMParameter (ASN1CTXT *pctxt, ASN1T_PBMParameter* pvalue);

/**************************************************************/
/*                                                            */
/*  EncryptedPKey                                             */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_EncryptedPKey_encryptedValue  1
#define T_EncryptedPKey_envelopedData   2

class EXTERN ASN1C_EncryptedPKey;

typedef struct EXTERN ASN1T_EncryptedPKey : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_EncryptedValue *encryptedValue;
      /* t = 2 */
      ASN1T_EnvelopedData *envelopedData;
   } u;
   ASN1T_EncryptedPKey () {}
   ASN1T_EncryptedPKey (ASN1C_EncryptedPKey& srcData);
   ~ASN1T_EncryptedPKey ();
} ASN1T_EncryptedPKey;

class EXTERN ASN1C_EncryptedPKey :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_EncryptedPKey& msgData;
   struct ElementID {
      enum {
         _unknown, encryptedValue, envelopedData
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_EncryptedValue* mpEncryptedValueC;
   class ASN1C_EnvelopedData* mpEnvelopedDataC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_EncryptedPKey (ASN1T_EncryptedPKey& data);
   ASN1C_EncryptedPKey (
      ASN1MessageBufferIF& msgBuf, ASN1T_EncryptedPKey& data);
   ASN1C_EncryptedPKey (ASN1C_EncryptedPKey& original);

   ~ASN1C_EncryptedPKey();
   // 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_EncryptedPKey& getCopy (ASN1T_EncryptedPKey* pDstData = 0);
   ASN1T_EncryptedPKey* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_EncryptedPKey (ASN1CTXT* pctxt,
   ASN1T_EncryptedPKey *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EncryptedPKey (ASN1CTXT* pctxt,
   ASN1T_EncryptedPKey *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_EncryptedPKey
  (ASN1CTXT* pctxt, ASN1T_EncryptedPKey* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_EncryptedPKey (ASN1CTXT *pctxt, ASN1T_EncryptedPKey* pSrcValue, ASN1T_EncryptedPKey* pDstValue);

EXTERN void asn1Free_EncryptedPKey (ASN1CTXT *pctxt, ASN1T_EncryptedPKey* pvalue);

/**************************************************************/
/*                                                            */
/*  PKIArchiveOptions                                         */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_PKIArchiveOptions_encryptedPrivKey 1
#define T_PKIArchiveOptions_keyGenParameters 2
#define T_PKIArchiveOptions_archiveRemGenPrivKey 3

class EXTERN ASN1C_PKIArchiveOptions;

typedef struct EXTERN ASN1T_PKIArchiveOptions : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_EncryptedPKey *encryptedPrivKey;
      /* t = 2 */
      ASN1T_KeyGenParameters *keyGenParameters;
      /* t = 3 */
      ASN1BOOL archiveRemGenPrivKey;
   } u;
   ASN1T_PKIArchiveOptions () {}
   ASN1T_PKIArchiveOptions (ASN1C_PKIArchiveOptions& srcData);
   ~ASN1T_PKIArchiveOptions ();
} ASN1T_PKIArchiveOptions;

class EXTERN ASN1C_PKIArchiveOptions :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PKIArchiveOptions& msgData;
   struct ElementID {
      enum {
         _unknown, encryptedPrivKey, keyGenParameters, archiveRemGenPrivKey
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_EncryptedPKey* mpEncryptedPrivKeyC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_PKIArchiveOptions (ASN1T_PKIArchiveOptions& data);
   ASN1C_PKIArchiveOptions (
      ASN1MessageBufferIF& msgBuf, ASN1T_PKIArchiveOptions& data);
   ASN1C_PKIArchiveOptions (ASN1C_PKIArchiveOptions& original);

   ~ASN1C_PKIArchiveOptions();
   // 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_PKIArchiveOptions& getCopy (ASN1T_PKIArchiveOptions* pDstData = 0);
   ASN1T_PKIArchiveOptions* newCopy ();

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PKIArchiveOptions (ASN1CTXT* pctxt,
   ASN1T_PKIArchiveOptions *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PKIArchiveOptions (ASN1CTXT* pctxt,
   ASN1T_PKIArchiveOptions *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PKIArchiveOptions
  (ASN1CTXT* pctxt, ASN1T_PKIArchiveOptions* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PKIArchiveOptions (ASN1CTXT *pctxt, ASN1T_PKIArchiveOptions* pSrcValue, ASN1T_PKIArchiveOptions* pDstValue);

EXTERN void asn1Free_PKIArchiveOptions (ASN1CTXT *pctxt, ASN1T_PKIArchiveOptions* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_pkip;
extern EXTERN ASN1OBJID id_regCtrl;
extern EXTERN ASN1OBJID id_regCtrl_regToken;
extern EXTERN ASN1OBJID id_regCtrl_authenticator;
extern EXTERN ASN1OBJID id_regCtrl_pkiPublicationInfo;
extern EXTERN ASN1OBJID id_regCtrl_pkiArchiveOptions;
extern EXTERN ASN1OBJID id_regCtrl_oldCertID;
extern EXTERN ASN1OBJID id_regCtrl_protocolEncrKey;
extern EXTERN ASN1OBJID id_regInfo;
extern EXTERN ASN1OBJID id_regInfo_utf8Pairs;
extern EXTERN ASN1OBJID id_regInfo_certReq;

}
#endif
