/**
 * This file was generated by the Objective Systems ASN1C Compiler
 * (http://www.obj-sys.com).  Version: 5.63.
 */
#ifndef PKIXDVCS_H
#define PKIXDVCS_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 "PKIXCMP.h"
#include "CryptographicMessageSyntax.h"
#include "PKIXOCSP.h"
#include "SecureMimeMessageV3.h"
namespace asn1data {

/**************************************************************/
/*                                                            */
/*  Nonce                                                     */
/*                                                            */
/**************************************************************/

typedef ASN1ConstCharPtr ASN1T_Nonce;

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

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

EXTERN int asn1E_Nonce (ASN1CTXT* pctxt,
   ASN1T_Nonce *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Nonce (ASN1CTXT* pctxt,
   ASN1T_Nonce *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Nonce
  (ASN1CTXT* pctxt, ASN1T_Nonce value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Nonce (ASN1CTXT *pctxt, ASN1T_Nonce* pSrcValue, ASN1T_Nonce* pDstValue);

/**************************************************************/
/*                                                            */
/*  ServiceType                                               */
/*                                                            */
/**************************************************************/

struct EXTERN ServiceType {
   enum Root {
      cpd = 1,
      vsd = 2,
      cpkc = 3,
      ccpd = 4
   } ;
} ;

typedef ASN1UINT ASN1T_ServiceType;

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

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

EXTERN int asn1E_ServiceType (ASN1CTXT* pctxt,
   ASN1T_ServiceType *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ServiceType (ASN1CTXT* pctxt,
   ASN1T_ServiceType *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_ServiceType
  (ASN1CTXT* pctxt, ASN1T_ServiceType value,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_ServiceType (ASN1CTXT *pctxt, ASN1T_ServiceType* pSrcValue, ASN1T_ServiceType* pDstValue);

/**************************************************************/
/*                                                            */
/*  DVCSTime                                                  */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_DVCSTime_timeStampToken       1
#define T_DVCSTime_genTime              2

class EXTERN ASN1C_DVCSTime;

typedef struct EXTERN ASN1T_DVCSTime : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_ContentInfo *timeStampToken;
      /* t = 2 */
      ASN1GeneralizedTime genTime;
   } u;
   ASN1T_DVCSTime () {}
   ASN1T_DVCSTime (ASN1C_DVCSTime& srcData);
   ~ASN1T_DVCSTime ();
} ASN1T_DVCSTime;

class EXTERN ASN1C_DVCSTime :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSTime& msgData;
   struct ElementID {
      enum {
         _unknown, timeStampToken, genTime
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_ContentInfo* mpTimeStampTokenC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_DVCSTime (ASN1T_DVCSTime& data);
   ASN1C_DVCSTime (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSTime& data);
   ASN1C_DVCSTime (ASN1C_DVCSTime& original);

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

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

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

   inline ASN1C_DVCSTime& operator= (ASN1C_DVCSTime& 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_DVCSTime (ASN1CTXT* pctxt,
   ASN1T_DVCSTime *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSTime (ASN1CTXT* pctxt,
   ASN1T_DVCSTime *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSTime
  (ASN1CTXT* pctxt, ASN1T_DVCSTime* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSTime (ASN1CTXT *pctxt, ASN1T_DVCSTime* pSrcValue, ASN1T_DVCSTime* pDstValue);

EXTERN void asn1Free_DVCSTime (ASN1CTXT *pctxt, ASN1T_DVCSTime* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSRequestInformation                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DVCSRequestInformation;

typedef struct EXTERN ASN1T_DVCSRequestInformation : public ASN1TPDU {
   struct {
      unsigned noncePresent : 1;
      unsigned requestTimePresent : 1;
      unsigned requesterPresent : 1;
      unsigned requestPolicyPresent : 1;
      unsigned dvcsPresent : 1;
      unsigned dataLocationsPresent : 1;
      unsigned extensionsPresent : 1;
   } m;
   ASN1ConstCharPtr version;
   ASN1T_ServiceType service;
   ASN1T_Nonce nonce;
   ASN1T_DVCSTime requestTime;
   ASN1T_GeneralNames requester;
   ASN1T_PolicyInformation requestPolicy;
   ASN1T_GeneralNames dvcs;
   ASN1T_GeneralNames dataLocations;
   ASN1T_Extensions extensions;
   ASN1T_DVCSRequestInformation ();
   ASN1T_DVCSRequestInformation (ASN1C_DVCSRequestInformation& srcData);
   ~ASN1T_DVCSRequestInformation ();
} ASN1T_DVCSRequestInformation;

class EXTERN ASN1C_DVCSRequestInformation :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSRequestInformation& msgData;
   struct ElementID {
      enum {
         _unknown, version, service, nonce, requestTime, requester,
         requestPolicy, dvcs, dataLocations, extensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DVCSTime* mpRequestTimeC;
   class ASN1C_GeneralNames* mpRequesterC;
   class ASN1C_PolicyInformation* mpRequestPolicyC;
   class ASN1C_GeneralNames* mpDvcsC;
   class ASN1C_GeneralNames* mpDataLocationsC;
   class ASN1C_Extensions* mpExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_DVCSRequestInformation (ASN1T_DVCSRequestInformation& data);
   ASN1C_DVCSRequestInformation (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSRequestInformation& data);
   ASN1C_DVCSRequestInformation (ASN1C_DVCSRequestInformation& original);

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

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

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

   inline ASN1C_DVCSRequestInformation& operator= (ASN1C_DVCSRequestInformation& 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_DVCSRequestInformation (ASN1CTXT* pctxt,
   ASN1T_DVCSRequestInformation *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSRequestInformation (ASN1CTXT* pctxt,
   ASN1T_DVCSRequestInformation *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSRequestInformation
  (ASN1CTXT* pctxt, ASN1T_DVCSRequestInformation* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSRequestInformation (ASN1CTXT *pctxt, ASN1T_DVCSRequestInformation* pSrcValue, ASN1T_DVCSRequestInformation* pDstValue);

EXTERN void asn1Free_DVCSRequestInformation (ASN1CTXT *pctxt, ASN1T_DVCSRequestInformation* pvalue);

/**************************************************************/
/*                                                            */
/*  Data_certs                                                */
/*                                                            */
/**************************************************************/

#define TV_Data_certs	(TM_CTXT|TM_CONS|0)

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

class EXTERN ASN1C_Data_certs :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_Data_certs& msgData;
   struct ASN1T_TargetEtcChain *mpElement;
   class ASN1C_TargetEtcChain* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_Data_certs (ASN1T_Data_certs& data);
   ASN1C_Data_certs (
      ASN1MessageBufferIF& msgBuf, ASN1T_Data_certs& data);
   ASN1C_Data_certs (ASN1C_Data_certs& original);

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

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

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

   ASN1C_Data_certs& operator= (ASN1C_Data_certs& srcData);
   void Append (struct ASN1T_TargetEtcChain * 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_Data_certs (ASN1CTXT* pctxt,
   ASN1T_Data_certs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Data_certs (ASN1CTXT* pctxt,
   ASN1T_Data_certs *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Data_certs
  (ASN1CTXT* pctxt, ASN1T_Data_certs* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Data_certs (ASN1CTXT *pctxt, ASN1T_Data_certs* pSrcValue, ASN1T_Data_certs* pDstValue);

EXTERN void asn1Free_Data_certs (ASN1CTXT *pctxt, ASN1T_Data_certs* pvalue);

/**************************************************************/
/*                                                            */
/*  Data                                                      */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_Data_message                  1
#define T_Data_messageImprint           2
#define T_Data_certs                    3

class EXTERN ASN1C_Data;

typedef struct EXTERN ASN1T_Data : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1TDynOctStr *message;
      /* t = 2 */
      ASN1T_DigestInfo *messageImprint;
      /* t = 3 */
      ASN1T_Data_certs *certs;
   } u;
   ASN1T_Data () {}
   ASN1T_Data (ASN1C_Data& srcData);
   ~ASN1T_Data ();
} ASN1T_Data;

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

   class ASN1C_DigestInfo* mpMessageImprintC;
   class ASN1C_Data_certs* mpCertsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
public:
   ASN1C_Data (ASN1T_Data& data);
   ASN1C_Data (
      ASN1MessageBufferIF& msgBuf, ASN1T_Data& data);
   ASN1C_Data (ASN1C_Data& original);

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

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

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

   inline ASN1C_Data& operator= (ASN1C_Data& 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_Data (ASN1CTXT* pctxt,
   ASN1T_Data *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Data (ASN1CTXT* pctxt,
   ASN1T_Data *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_Data
  (ASN1CTXT* pctxt, ASN1T_Data* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_Data (ASN1CTXT *pctxt, ASN1T_Data* pSrcValue, ASN1T_Data* pDstValue);

EXTERN void asn1Free_Data (ASN1CTXT *pctxt, ASN1T_Data* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSRequest                                               */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DVCSRequest;

typedef struct EXTERN ASN1T_DVCSRequest : public ASN1TPDU {
   struct {
      unsigned transactionIdentifierPresent : 1;
   } m;
   ASN1T_DVCSRequestInformation requestInformation;
   ASN1T_Data data;
   ASN1T_GeneralName transactionIdentifier;
   ASN1T_DVCSRequest ();
   ASN1T_DVCSRequest (ASN1C_DVCSRequest& srcData);
   ~ASN1T_DVCSRequest ();
} ASN1T_DVCSRequest;

class EXTERN ASN1C_DVCSRequest :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSRequest& msgData;
   struct ElementID {
      enum {
         _unknown, requestInformation, data, transactionIdentifier
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DVCSRequestInformation* mpRequestInformationC;
   class ASN1C_Data* mpDataC;
   class ASN1C_GeneralName* mpTransactionIdentifierC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_DVCSRequest (ASN1T_DVCSRequest& data);
   ASN1C_DVCSRequest (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSRequest& data);
   ASN1C_DVCSRequest (ASN1C_DVCSRequest& original);

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

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

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

   inline ASN1C_DVCSRequest& operator= (ASN1C_DVCSRequest& 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_DVCSRequest (ASN1CTXT* pctxt,
   ASN1T_DVCSRequest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSRequest (ASN1CTXT* pctxt,
   ASN1T_DVCSRequest *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSRequest
  (ASN1CTXT* pctxt, ASN1T_DVCSRequest* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSRequest (ASN1CTXT *pctxt, ASN1T_DVCSRequest* pSrcValue, ASN1T_DVCSRequest* pDstValue);

EXTERN void asn1Free_DVCSRequest (ASN1CTXT *pctxt, ASN1T_DVCSRequest* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSCertInfo_certs                                        */
/*                                                            */
/**************************************************************/

#define TV_DVCSCertInfo_certs	(TM_CTXT|TM_CONS|3)

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

class EXTERN ASN1C_DVCSCertInfo_certs :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSCertInfo_certs& msgData;
   struct ASN1T_TargetEtcChain *mpElement;
   class ASN1C_TargetEtcChain* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_DVCSCertInfo_certs (ASN1T_DVCSCertInfo_certs& data);
   ASN1C_DVCSCertInfo_certs (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSCertInfo_certs& data);
   ASN1C_DVCSCertInfo_certs (ASN1C_DVCSCertInfo_certs& original);

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

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

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

   ASN1C_DVCSCertInfo_certs& operator= (ASN1C_DVCSCertInfo_certs& srcData);
   void Append (struct ASN1T_TargetEtcChain * 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_DVCSCertInfo_certs (ASN1CTXT* pctxt,
   ASN1T_DVCSCertInfo_certs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSCertInfo_certs (ASN1CTXT* pctxt,
   ASN1T_DVCSCertInfo_certs *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSCertInfo_certs
  (ASN1CTXT* pctxt, ASN1T_DVCSCertInfo_certs* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSCertInfo_certs (ASN1CTXT *pctxt, ASN1T_DVCSCertInfo_certs* pSrcValue, ASN1T_DVCSCertInfo_certs* pDstValue);

EXTERN void asn1Free_DVCSCertInfo_certs (ASN1CTXT *pctxt, ASN1T_DVCSCertInfo_certs* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSCertInfo                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DVCSCertInfo;

typedef struct EXTERN ASN1T_DVCSCertInfo : public ASN1TPDU {
   struct {
      unsigned dvStatusPresent : 1;
      unsigned policyPresent : 1;
      unsigned reqSignaturePresent : 1;
      unsigned certsPresent : 1;
      unsigned extensionsPresent : 1;
   } m;
   ASN1ConstCharPtr version;
   ASN1T_DVCSRequestInformation dvReqInfo;
   ASN1T_DigestInfo messageImprint;
   ASN1ConstCharPtr serialNumber;
   ASN1T_DVCSTime responseTime;
   ASN1T_PKIStatusInfo dvStatus;
   ASN1T_PolicyInformation policy;
   ASN1T_SignerInfos reqSignature;
   ASN1T_DVCSCertInfo_certs certs;
   ASN1T_Extensions extensions;
   ASN1T_DVCSCertInfo ();
   ASN1T_DVCSCertInfo (ASN1C_DVCSCertInfo& srcData);
   ~ASN1T_DVCSCertInfo ();
} ASN1T_DVCSCertInfo;

class EXTERN ASN1C_DVCSCertInfo :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSCertInfo& msgData;
   struct ElementID {
      enum {
         _unknown, version, dvReqInfo, messageImprint, serialNumber,
         responseTime, dvStatus, policy, reqSignature, certs, extensions
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DVCSRequestInformation* mpDvReqInfoC;
   class ASN1C_DigestInfo* mpMessageImprintC;
   class ASN1C_DVCSTime* mpResponseTimeC;
   class ASN1C_PKIStatusInfo* mpDvStatusC;
   class ASN1C_PolicyInformation* mpPolicyC;
   class ASN1C_SignerInfos* mpReqSignatureC;
   class ASN1C_DVCSCertInfo_certs* mpCertsC;
   class ASN1C_Extensions* mpExtensionsC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_DVCSCertInfo (ASN1T_DVCSCertInfo& data);
   ASN1C_DVCSCertInfo (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSCertInfo& data);
   ASN1C_DVCSCertInfo (ASN1C_DVCSCertInfo& original);

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

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

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

   inline ASN1C_DVCSCertInfo& operator= (ASN1C_DVCSCertInfo& 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_DVCSCertInfo (ASN1CTXT* pctxt,
   ASN1T_DVCSCertInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSCertInfo (ASN1CTXT* pctxt,
   ASN1T_DVCSCertInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSCertInfo
  (ASN1CTXT* pctxt, ASN1T_DVCSCertInfo* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSCertInfo (ASN1CTXT *pctxt, ASN1T_DVCSCertInfo* pSrcValue, ASN1T_DVCSCertInfo* pDstValue);

EXTERN void asn1Free_DVCSCertInfo (ASN1CTXT *pctxt, ASN1T_DVCSCertInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSErrorNotice                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_DVCSErrorNotice;

typedef struct EXTERN ASN1T_DVCSErrorNotice : public ASN1TPDU {
   struct {
      unsigned transactionIdentifierPresent : 1;
   } m;
   ASN1T_PKIStatusInfo transactionStatus;
   ASN1T_GeneralName transactionIdentifier;
   ASN1T_DVCSErrorNotice ();
   ASN1T_DVCSErrorNotice (ASN1C_DVCSErrorNotice& srcData);
   ~ASN1T_DVCSErrorNotice ();
} ASN1T_DVCSErrorNotice;

class EXTERN ASN1C_DVCSErrorNotice :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSErrorNotice& msgData;
   struct ElementID {
      enum {
         _unknown, transactionStatus, transactionIdentifier
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PKIStatusInfo* mpTransactionStatusC;
   class ASN1C_GeneralName* mpTransactionIdentifierC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_DVCSErrorNotice (ASN1T_DVCSErrorNotice& data);
   ASN1C_DVCSErrorNotice (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSErrorNotice& data);
   ASN1C_DVCSErrorNotice (ASN1C_DVCSErrorNotice& original);

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

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

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

   inline ASN1C_DVCSErrorNotice& operator= (ASN1C_DVCSErrorNotice& 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_DVCSErrorNotice (ASN1CTXT* pctxt,
   ASN1T_DVCSErrorNotice *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSErrorNotice (ASN1CTXT* pctxt,
   ASN1T_DVCSErrorNotice *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSErrorNotice
  (ASN1CTXT* pctxt, ASN1T_DVCSErrorNotice* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSErrorNotice (ASN1CTXT *pctxt, ASN1T_DVCSErrorNotice* pSrcValue, ASN1T_DVCSErrorNotice* pDstValue);

EXTERN void asn1Free_DVCSErrorNotice (ASN1CTXT *pctxt, ASN1T_DVCSErrorNotice* pvalue);

/**************************************************************/
/*                                                            */
/*  DVCSResponse                                              */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_DVCSResponse_dvCertInfo       1
#define T_DVCSResponse_dvErrorNote      2

class EXTERN ASN1C_DVCSResponse;

typedef struct EXTERN ASN1T_DVCSResponse : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_DVCSCertInfo *dvCertInfo;
      /* t = 2 */
      ASN1T_DVCSErrorNotice *dvErrorNote;
   } u;
   ASN1T_DVCSResponse () {}
   ASN1T_DVCSResponse (ASN1C_DVCSResponse& srcData);
   ~ASN1T_DVCSResponse ();
} ASN1T_DVCSResponse;

class EXTERN ASN1C_DVCSResponse :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_DVCSResponse& msgData;
   struct ElementID {
      enum {
         _unknown, dvCertInfo, dvErrorNote
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_DVCSCertInfo* mpDvCertInfoC;
   class ASN1C_DVCSErrorNotice* mpDvErrorNoteC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_DVCSResponse (ASN1T_DVCSResponse& data);
   ASN1C_DVCSResponse (
      ASN1MessageBufferIF& msgBuf, ASN1T_DVCSResponse& data);
   ASN1C_DVCSResponse (ASN1C_DVCSResponse& original);

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

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

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

   inline ASN1C_DVCSResponse& operator= (ASN1C_DVCSResponse& 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_DVCSResponse (ASN1CTXT* pctxt,
   ASN1T_DVCSResponse *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DVCSResponse (ASN1CTXT* pctxt,
   ASN1T_DVCSResponse *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_DVCSResponse
  (ASN1CTXT* pctxt, ASN1T_DVCSResponse* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_DVCSResponse (ASN1CTXT *pctxt, ASN1T_DVCSResponse* pSrcValue, ASN1T_DVCSResponse* pDstValue);

EXTERN void asn1Free_DVCSResponse (ASN1CTXT *pctxt, ASN1T_DVCSResponse* pvalue);

/**************************************************************/
/*                                                            */
/*  CertEtcToken                                              */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_CertEtcToken_extension        1
#define T_CertEtcToken_certificate      2
#define T_CertEtcToken_esscertid        3
#define T_CertEtcToken_pkistatus        4
#define T_CertEtcToken_assertion        5
#define T_CertEtcToken_crl              6
#define T_CertEtcToken_ocspcertstatus   7
#define T_CertEtcToken_oscpcertid       8
#define T_CertEtcToken_oscpresponse     9
#define T_CertEtcToken_capabilities     10

class EXTERN ASN1C_CertEtcToken;

typedef struct EXTERN ASN1T_CertEtcToken : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_Extension *extension;
      /* t = 2 */
      ASN1T_Certificate *certificate;
      /* t = 3 */
      ASN1T_ESSCertID *esscertid;
      /* t = 4 */
      ASN1T_PKIStatusInfo *pkistatus;
      /* t = 5 */
      ASN1T_ContentInfo *assertion;
      /* t = 6 */
      ASN1T_CertificateList *crl;
      /* t = 7 */
      ASN1T_CertStatus *ocspcertstatus;
      /* t = 8 */
      ASN1T_CertID *oscpcertid;
      /* t = 9 */
      ASN1T_OCSPResponse *oscpresponse;
      /* t = 10 */
      ASN1T_SMIMECapabilities *capabilities;
   } u;
   ASN1T_CertEtcToken () {}
   ASN1T_CertEtcToken (ASN1C_CertEtcToken& srcData);
   ~ASN1T_CertEtcToken ();
} ASN1T_CertEtcToken;

class EXTERN ASN1C_CertEtcToken :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_CertEtcToken& msgData;
   struct ElementID {
      enum {
         _unknown, extension, certificate, esscertid, pkistatus, assertion,
         crl, ocspcertstatus, oscpcertid, oscpresponse, capabilities
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_Extension* mpExtensionC;
   class ASN1C_Certificate* mpCertificateC;
   class ASN1C_ESSCertID* mpEsscertidC;
   class ASN1C_PKIStatusInfo* mpPkistatusC;
   class ASN1C_ContentInfo* mpAssertionC;
   class ASN1C_CertificateList* mpCrlC;
   class ASN1C_CertStatus* mpOcspcertstatusC;
   class ASN1C_CertID* mpOscpcertidC;
   class ASN1C_OCSPResponse* mpOscpresponseC;
   class ASN1C_SMIMECapabilities* mpCapabilitiesC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
public:
   ASN1C_CertEtcToken (ASN1T_CertEtcToken& data);
   ASN1C_CertEtcToken (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertEtcToken& data);
   ASN1C_CertEtcToken (ASN1C_CertEtcToken& original);

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

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

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

   inline ASN1C_CertEtcToken& operator= (ASN1C_CertEtcToken& 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_CertEtcToken (ASN1CTXT* pctxt,
   ASN1T_CertEtcToken *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertEtcToken (ASN1CTXT* pctxt,
   ASN1T_CertEtcToken *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_CertEtcToken
  (ASN1CTXT* pctxt, ASN1T_CertEtcToken* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_CertEtcToken (ASN1CTXT *pctxt, ASN1T_CertEtcToken* pSrcValue, ASN1T_CertEtcToken* pDstValue);

EXTERN void asn1Free_CertEtcToken (ASN1CTXT *pctxt, ASN1T_CertEtcToken* pvalue);

/**************************************************************/
/*                                                            */
/*  TargetEtcChain_chain                                      */
/*                                                            */
/**************************************************************/

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

class EXTERN ASN1C_TargetEtcChain_chain :
   public ASN1CSeqOfList, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TargetEtcChain_chain& msgData;
   ASN1T_CertEtcToken *mpElement;
   class ASN1C_CertEtcToken* mpElementC;
   ASN1XERSAXDecodeHandler* mpCurrElem;

public:
   ASN1C_TargetEtcChain_chain (ASN1T_TargetEtcChain_chain& data);
   ASN1C_TargetEtcChain_chain (
      ASN1MessageBufferIF& msgBuf, ASN1T_TargetEtcChain_chain& data);
   ASN1C_TargetEtcChain_chain (ASN1C_TargetEtcChain_chain& original);

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

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

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

   ASN1C_TargetEtcChain_chain& operator= (ASN1C_TargetEtcChain_chain& srcData);
   void Append (ASN1T_CertEtcToken * 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_TargetEtcChain_chain (ASN1CTXT* pctxt,
   ASN1T_TargetEtcChain_chain *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TargetEtcChain_chain (ASN1CTXT* pctxt,
   ASN1T_TargetEtcChain_chain *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TargetEtcChain_chain
  (ASN1CTXT* pctxt, ASN1T_TargetEtcChain_chain* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TargetEtcChain_chain (ASN1CTXT *pctxt, ASN1T_TargetEtcChain_chain* pSrcValue, ASN1T_TargetEtcChain_chain* pDstValue);

EXTERN void asn1Free_TargetEtcChain_chain (ASN1CTXT *pctxt, ASN1T_TargetEtcChain_chain* pvalue);

/**************************************************************/
/*                                                            */
/*  PathProcInput_acceptablePolicySet                         */
/*                                                            */
/**************************************************************/

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

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

public:
   ASN1C_PathProcInput_acceptablePolicySet (ASN1T_PathProcInput_acceptablePolicySet& data);
   ASN1C_PathProcInput_acceptablePolicySet (
      ASN1MessageBufferIF& msgBuf, ASN1T_PathProcInput_acceptablePolicySet& data);
   ASN1C_PathProcInput_acceptablePolicySet (ASN1C_PathProcInput_acceptablePolicySet& original);

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

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

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

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

   // SAX ContentHandler interface

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

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

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

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

EXTERN int asn1E_PathProcInput_acceptablePolicySet (ASN1CTXT* pctxt,
   ASN1T_PathProcInput_acceptablePolicySet *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PathProcInput_acceptablePolicySet (ASN1CTXT* pctxt,
   ASN1T_PathProcInput_acceptablePolicySet *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PathProcInput_acceptablePolicySet
  (ASN1CTXT* pctxt, ASN1T_PathProcInput_acceptablePolicySet* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PathProcInput_acceptablePolicySet (ASN1CTXT *pctxt, ASN1T_PathProcInput_acceptablePolicySet* pSrcValue, ASN1T_PathProcInput_acceptablePolicySet* pDstValue);

EXTERN void asn1Free_PathProcInput_acceptablePolicySet (ASN1CTXT *pctxt, ASN1T_PathProcInput_acceptablePolicySet* pvalue);

/**************************************************************/
/*                                                            */
/*  PathProcInput                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_PathProcInput;

typedef struct EXTERN ASN1T_PathProcInput : public ASN1TPDU {
   ASN1T_PathProcInput_acceptablePolicySet acceptablePolicySet;
   ASN1BOOL inhibitPolicyMapping;
   ASN1BOOL explicitPolicyReqd;
   ASN1BOOL inhibitAnyPolicy;
   ASN1T_PathProcInput ();
   ASN1T_PathProcInput (ASN1C_PathProcInput& srcData);
   ~ASN1T_PathProcInput ();
} ASN1T_PathProcInput;

class EXTERN ASN1C_PathProcInput :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_PathProcInput& msgData;
   struct ElementID {
      enum {
         _unknown, acceptablePolicySet, inhibitPolicyMapping,
         explicitPolicyReqd, inhibitAnyPolicy
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_PathProcInput_acceptablePolicySet* mpAcceptablePolicySetC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   ASN1MemBuf mCurrElemValue;
   int mReqElemCnt;
public:
   ASN1C_PathProcInput (ASN1T_PathProcInput& data);
   ASN1C_PathProcInput (
      ASN1MessageBufferIF& msgBuf, ASN1T_PathProcInput& data);
   ASN1C_PathProcInput (ASN1C_PathProcInput& original);

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

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

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

   inline ASN1C_PathProcInput& operator= (ASN1C_PathProcInput& 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_PathProcInput (ASN1CTXT* pctxt,
   ASN1T_PathProcInput *pvalue, ASN1TagType tagging);

EXTERN int asn1D_PathProcInput (ASN1CTXT* pctxt,
   ASN1T_PathProcInput *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_PathProcInput
  (ASN1CTXT* pctxt, ASN1T_PathProcInput* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_PathProcInput (ASN1CTXT *pctxt, ASN1T_PathProcInput* pSrcValue, ASN1T_PathProcInput* pDstValue);

EXTERN void asn1Free_PathProcInput (ASN1CTXT *pctxt, ASN1T_PathProcInput* pvalue);

/**************************************************************/
/*                                                            */
/*  TargetEtcChain                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TargetEtcChain;

typedef struct EXTERN ASN1T_TargetEtcChain : public ASN1TPDU {
   struct {
      unsigned chainPresent : 1;
      unsigned pathProcInputPresent : 1;
   } m;
   ASN1T_CertEtcToken target;
   ASN1T_TargetEtcChain_chain chain;
   ASN1T_PathProcInput pathProcInput;
   ASN1T_TargetEtcChain ();
   ASN1T_TargetEtcChain (ASN1C_TargetEtcChain& srcData);
   ~ASN1T_TargetEtcChain ();
} ASN1T_TargetEtcChain;

class EXTERN ASN1C_TargetEtcChain :
   public ASN1CType, public ASN1XERSAXDecodeHandler
{
protected:
   ASN1T_TargetEtcChain& msgData;
   struct ElementID {
      enum {
         _unknown, target, chain, pathProcInput
      } ;
   } ;
   int getElementID 
      (const XMLCHAR* const uri, const XMLCHAR* const localname,
       const XMLCHAR* const qname);

   class ASN1C_CertEtcToken* mpTargetC;
   class ASN1C_TargetEtcChain_chain* mpChainC;
   class ASN1C_PathProcInput* mpPathProcInputC;
   ASN1XERSAXDecodeHandler* mpCurrElem;
   int mReqElemCnt;
public:
   ASN1C_TargetEtcChain (ASN1T_TargetEtcChain& data);
   ASN1C_TargetEtcChain (
      ASN1MessageBufferIF& msgBuf, ASN1T_TargetEtcChain& data);
   ASN1C_TargetEtcChain (ASN1C_TargetEtcChain& original);

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

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

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

   inline ASN1C_TargetEtcChain& operator= (ASN1C_TargetEtcChain& 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_TargetEtcChain (ASN1CTXT* pctxt,
   ASN1T_TargetEtcChain *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TargetEtcChain (ASN1CTXT* pctxt,
   ASN1T_TargetEtcChain *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XE_TargetEtcChain
  (ASN1CTXT* pctxt, ASN1T_TargetEtcChain* pvalue,
   ASN1ConstCharPtr elemName, ASN1ConstCharPtr attributes);

EXTERN void asn1Copy_TargetEtcChain (ASN1CTXT *pctxt, ASN1T_TargetEtcChain* pSrcValue, ASN1T_TargetEtcChain* pDstValue);

EXTERN void asn1Free_TargetEtcChain (ASN1CTXT *pctxt, ASN1T_TargetEtcChain* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_ad_dvcs;
extern EXTERN ASN1OBJID id_kp_dvcs;
extern EXTERN ASN1OBJID id_smime;
extern EXTERN ASN1OBJID id_ct_DVCSRequestData;
extern EXTERN ASN1OBJID id_ct_DVCSResponseData;
extern EXTERN ASN1OBJID id_aa_dvcs_dvc;

}
#endif
