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

#include <stdio.h>
#include <stdlib.h>
#include "asn1BerCppTypes.h"
#include "rtTable.h"
#include "ASN1CSeqOfList.h"
#include "PKIX1Explicit88.h"
#include "AuthenticationFramework.h"
#include "PKIXOCSP.h"
#include "PKIXTSP.h"
#include "CertificateExtensions.h"
namespace asn1data {

/**************************************************************/
/*                                                            */
/*  SignaturePolicyImplied                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SignaturePolicyImplied :
   public ASN1CType
{
protected:
public:
   ASN1C_SignaturePolicyImplied ();
   ASN1C_SignaturePolicyImplied (
      ASN1MessageBufferIF& msgBuf);
   ASN1C_SignaturePolicyImplied (ASN1C_SignaturePolicyImplied& original);

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

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


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

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

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

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

/**************************************************************/
/*                                                            */
/*  SigPolicyId                                               */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_SigPolicyId;

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

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

EXTERN int asn1E_SigPolicyId (ASN1CTXT* pctxt,
   ASN1T_SigPolicyId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SigPolicyId (ASN1CTXT* pctxt,
   ASN1T_SigPolicyId *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SigPolicyId (ASN1CTXT *pctxt, ASN1T_SigPolicyId* pSrcValue, ASN1T_SigPolicyId* pDstValue);

/**************************************************************/
/*                                                            */
/*  SigPolicyHash                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SigPolicyHash;

typedef ASN1T_OtherHashAlgAndValue ASN1T_SigPolicyHash;

class EXTERN ASN1C_SigPolicyHash :
   public ASN1C_OtherHashAlgAndValue
{
protected:
public:
   ASN1C_SigPolicyHash (ASN1T_SigPolicyHash& data);
   ASN1C_SigPolicyHash (
      ASN1MessageBufferIF& msgBuf, ASN1T_SigPolicyHash& data);
   ASN1C_SigPolicyHash (ASN1C_SigPolicyHash& 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_SigPolicyHash& getCopy (ASN1T_SigPolicyHash* pDstData = 0);
   ASN1T_SigPolicyHash* newCopy ();

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

EXTERN int asn1E_SigPolicyHash (ASN1CTXT* pctxt,
   ASN1T_SigPolicyHash *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SigPolicyHash (ASN1CTXT* pctxt,
   ASN1T_SigPolicyHash *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SigPolicyHash (ASN1CTXT *pctxt, ASN1T_SigPolicyHash* pSrcValue, ASN1T_SigPolicyHash* pDstValue);

EXTERN void asn1Free_SigPolicyHash (ASN1CTXT *pctxt, ASN1T_SigPolicyHash* pvalue);

/**************************************************************/
/*                                                            */
/*  SPuri                                                     */
/*                                                            */
/**************************************************************/

typedef ASN1IA5String ASN1T_SPuri;

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

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

EXTERN int asn1E_SPuri (ASN1CTXT* pctxt,
   ASN1T_SPuri *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SPuri (ASN1CTXT* pctxt,
   ASN1T_SPuri *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SPuri (ASN1CTXT *pctxt, ASN1T_SPuri* pSrcValue, ASN1T_SPuri* pDstValue);

EXTERN void asn1Free_SPuri (ASN1CTXT *pctxt, ASN1T_SPuri* pvalue);

/**************************************************************/
/*                                                            */
/*  CommitmentTypeIdentifier                                  */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_CommitmentTypeIdentifier;

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

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

EXTERN int asn1E_CommitmentTypeIdentifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CommitmentTypeIdentifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CommitmentTypeIdentifier (ASN1CTXT *pctxt, ASN1T_CommitmentTypeIdentifier* pSrcValue, ASN1T_CommitmentTypeIdentifier* pDstValue);

/**************************************************************/
/*                                                            */
/*  CompleteCertificateRefs                                   */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_CompleteCertificateRefs& operator= (ASN1C_CompleteCertificateRefs& srcData);
   void Append (ASN1T_OtherCertID * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_CompleteCertificateRefs (ASN1CTXT* pctxt,
   ASN1T_CompleteCertificateRefs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CompleteCertificateRefs (ASN1CTXT* pctxt,
   ASN1T_CompleteCertificateRefs *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CompleteCertificateRefs (ASN1CTXT *pctxt, ASN1T_CompleteCertificateRefs* pSrcValue, ASN1T_CompleteCertificateRefs* pDstValue);

EXTERN void asn1Free_CompleteCertificateRefs (ASN1CTXT *pctxt, ASN1T_CompleteCertificateRefs* pvalue);

/**************************************************************/
/*                                                            */
/*  CrlIdentifier                                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CrlIdentifier;

typedef struct EXTERN ASN1T_CrlIdentifier : public ASN1TPDU {
   struct {
      unsigned longCrlNumberPresent : 1;
   } m;
   ASN1T_Name crlissuer;
   ASN1UTCTime crlIssuedTime;
   ASN1T_CRLNumber longCrlNumber;
   ASN1T_CrlIdentifier ();
   ASN1T_CrlIdentifier (ASN1C_CrlIdentifier& srcData);
   ~ASN1T_CrlIdentifier ();
} ASN1T_CrlIdentifier;

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

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

EXTERN int asn1E_CrlIdentifier (ASN1CTXT* pctxt,
   ASN1T_CrlIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CrlIdentifier (ASN1CTXT* pctxt,
   ASN1T_CrlIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CrlIdentifier (ASN1CTXT *pctxt, ASN1T_CrlIdentifier* pSrcValue, ASN1T_CrlIdentifier* pDstValue);

EXTERN void asn1Free_CrlIdentifier (ASN1CTXT *pctxt, ASN1T_CrlIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  CrlValidatedID                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CrlValidatedID;

typedef struct EXTERN ASN1T_CrlValidatedID : public ASN1TPDU {
   struct {
      unsigned crlIdentifierPresent : 1;
   } m;
   ASN1T_OtherHash crlHash;
   ASN1T_CrlIdentifier crlIdentifier;
   ASN1T_CrlValidatedID ();
   ASN1T_CrlValidatedID (ASN1C_CrlValidatedID& srcData);
   ~ASN1T_CrlValidatedID ();
} ASN1T_CrlValidatedID;

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

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

EXTERN int asn1E_CrlValidatedID (ASN1CTXT* pctxt,
   ASN1T_CrlValidatedID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CrlValidatedID (ASN1CTXT* pctxt,
   ASN1T_CrlValidatedID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CrlValidatedID (ASN1CTXT *pctxt, ASN1T_CrlValidatedID* pSrcValue, ASN1T_CrlValidatedID* pDstValue);

EXTERN void asn1Free_CrlValidatedID (ASN1CTXT *pctxt, ASN1T_CrlValidatedID* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfCrlValidatedID                                      */
/*                                                            */
/**************************************************************/

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

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

   ASN1C__SeqOfCrlValidatedID& operator= (ASN1C__SeqOfCrlValidatedID& srcData);
   void Append (ASN1T_CrlValidatedID * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SeqOfCrlValidatedID (ASN1CTXT* pctxt,
   ASN1T__SeqOfCrlValidatedID *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfCrlValidatedID (ASN1CTXT* pctxt,
   ASN1T__SeqOfCrlValidatedID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfCrlValidatedID (ASN1CTXT *pctxt, ASN1T__SeqOfCrlValidatedID* pSrcValue, ASN1T__SeqOfCrlValidatedID* pDstValue);

EXTERN void asn1Free__SeqOfCrlValidatedID (ASN1CTXT *pctxt, ASN1T__SeqOfCrlValidatedID* pvalue);

/**************************************************************/
/*                                                            */
/*  CRLListID                                                 */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CRLListID;

typedef struct EXTERN ASN1T_CRLListID : public ASN1TPDU {
   ASN1T__SeqOfCrlValidatedID crls;
   ASN1T_CRLListID ();
   ASN1T_CRLListID (ASN1C_CRLListID& srcData);
   ~ASN1T_CRLListID ();
} ASN1T_CRLListID;

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

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

EXTERN int asn1E_CRLListID (ASN1CTXT* pctxt,
   ASN1T_CRLListID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CRLListID (ASN1CTXT* pctxt,
   ASN1T_CRLListID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CRLListID (ASN1CTXT *pctxt, ASN1T_CRLListID* pSrcValue, ASN1T_CRLListID* pDstValue);

EXTERN void asn1Free_CRLListID (ASN1CTXT *pctxt, ASN1T_CRLListID* pvalue);

/**************************************************************/
/*                                                            */
/*  OcspIdentifier                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OcspIdentifier;

typedef struct EXTERN ASN1T_OcspIdentifier : public ASN1TPDU {
   ASN1T_ResponderID ocspResponderID;
   ASN1GeneralizedTime producedAt;
   ASN1T_OcspIdentifier ();
   ASN1T_OcspIdentifier (ASN1C_OcspIdentifier& srcData);
   ~ASN1T_OcspIdentifier ();
} ASN1T_OcspIdentifier;

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

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

EXTERN int asn1E_OcspIdentifier (ASN1CTXT* pctxt,
   ASN1T_OcspIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OcspIdentifier (ASN1CTXT* pctxt,
   ASN1T_OcspIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OcspIdentifier (ASN1CTXT *pctxt, ASN1T_OcspIdentifier* pSrcValue, ASN1T_OcspIdentifier* pDstValue);

EXTERN void asn1Free_OcspIdentifier (ASN1CTXT *pctxt, ASN1T_OcspIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  OcspResponsesID                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OcspResponsesID;

typedef struct EXTERN ASN1T_OcspResponsesID : public ASN1TPDU {
   struct {
      unsigned ocspRepHashPresent : 1;
   } m;
   ASN1T_OcspIdentifier ocspIdentifier;
   ASN1T_OtherHash ocspRepHash;
   ASN1T_OcspResponsesID ();
   ASN1T_OcspResponsesID (ASN1C_OcspResponsesID& srcData);
   ~ASN1T_OcspResponsesID ();
} ASN1T_OcspResponsesID;

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

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

EXTERN int asn1E_OcspResponsesID (ASN1CTXT* pctxt,
   ASN1T_OcspResponsesID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OcspResponsesID (ASN1CTXT* pctxt,
   ASN1T_OcspResponsesID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OcspResponsesID (ASN1CTXT *pctxt, ASN1T_OcspResponsesID* pSrcValue, ASN1T_OcspResponsesID* pDstValue);

EXTERN void asn1Free_OcspResponsesID (ASN1CTXT *pctxt, ASN1T_OcspResponsesID* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfOcspResponsesID                                     */
/*                                                            */
/**************************************************************/

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

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

   ASN1C__SeqOfOcspResponsesID& operator= (ASN1C__SeqOfOcspResponsesID& srcData);
   void Append (ASN1T_OcspResponsesID * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SeqOfOcspResponsesID (ASN1CTXT* pctxt,
   ASN1T__SeqOfOcspResponsesID *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfOcspResponsesID (ASN1CTXT* pctxt,
   ASN1T__SeqOfOcspResponsesID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfOcspResponsesID (ASN1CTXT *pctxt, ASN1T__SeqOfOcspResponsesID* pSrcValue, ASN1T__SeqOfOcspResponsesID* pDstValue);

EXTERN void asn1Free__SeqOfOcspResponsesID (ASN1CTXT *pctxt, ASN1T__SeqOfOcspResponsesID* pvalue);

/**************************************************************/
/*                                                            */
/*  OcspListID                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OcspListID;

typedef struct EXTERN ASN1T_OcspListID : public ASN1TPDU {
   ASN1T__SeqOfOcspResponsesID ocspResponses;
   ASN1T_OcspListID ();
   ASN1T_OcspListID (ASN1C_OcspListID& srcData);
   ~ASN1T_OcspListID ();
} ASN1T_OcspListID;

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

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

EXTERN int asn1E_OcspListID (ASN1CTXT* pctxt,
   ASN1T_OcspListID *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OcspListID (ASN1CTXT* pctxt,
   ASN1T_OcspListID *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OcspListID (ASN1CTXT *pctxt, ASN1T_OcspListID* pSrcValue, ASN1T_OcspListID* pDstValue);

EXTERN void asn1Free_OcspListID (ASN1CTXT *pctxt, ASN1T_OcspListID* pvalue);

/**************************************************************/
/*                                                            */
/*  CrlOcspRef                                                */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CrlOcspRef;

typedef struct EXTERN ASN1T_CrlOcspRef : public ASN1TPDU {
   struct {
      unsigned crlidsPresent : 1;
      unsigned ocspidsPresent : 1;
      unsigned otherRevPresent : 1;
   } m;
   ASN1T_CRLListID crlids;
   ASN1T_OcspListID ocspids;
   ASN1TOpenType otherRev;
   ASN1T_CrlOcspRef ();
   ASN1T_CrlOcspRef (ASN1C_CrlOcspRef& srcData);
   ~ASN1T_CrlOcspRef ();
} ASN1T_CrlOcspRef;

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

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

EXTERN int asn1E_CrlOcspRef (ASN1CTXT* pctxt,
   ASN1T_CrlOcspRef *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CrlOcspRef (ASN1CTXT* pctxt,
   ASN1T_CrlOcspRef *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CrlOcspRef (ASN1CTXT *pctxt, ASN1T_CrlOcspRef* pSrcValue, ASN1T_CrlOcspRef* pDstValue);

EXTERN void asn1Free_CrlOcspRef (ASN1CTXT *pctxt, ASN1T_CrlOcspRef* pvalue);

/**************************************************************/
/*                                                            */
/*  CompleteRevocationRefs                                    */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_CompleteRevocationRefs& operator= (ASN1C_CompleteRevocationRefs& srcData);
   void Append (ASN1T_CrlOcspRef * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_CompleteRevocationRefs (ASN1CTXT* pctxt,
   ASN1T_CompleteRevocationRefs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CompleteRevocationRefs (ASN1CTXT* pctxt,
   ASN1T_CompleteRevocationRefs *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CompleteRevocationRefs (ASN1CTXT *pctxt, ASN1T_CompleteRevocationRefs* pSrcValue, ASN1T_CompleteRevocationRefs* pDstValue);

EXTERN void asn1Free_CompleteRevocationRefs (ASN1CTXT *pctxt, ASN1T_CompleteRevocationRefs* pvalue);

/**************************************************************/
/*                                                            */
/*  CertificateValues                                         */
/*                                                            */
/**************************************************************/

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

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

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

EXTERN int asn1E_CertificateValues (ASN1CTXT* pctxt,
   ASN1T_CertificateValues *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertificateValues (ASN1CTXT* pctxt,
   ASN1T_CertificateValues *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertificateValues (ASN1CTXT *pctxt, ASN1T_CertificateValues* pSrcValue, ASN1T_CertificateValues* pDstValue);

EXTERN void asn1Free_CertificateValues (ASN1CTXT *pctxt, ASN1T_CertificateValues* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfCertificateList                                     */
/*                                                            */
/**************************************************************/

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

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

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

EXTERN int asn1E__SeqOfCertificateList (ASN1CTXT* pctxt,
   ASN1T__SeqOfCertificateList *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfCertificateList (ASN1CTXT* pctxt,
   ASN1T__SeqOfCertificateList *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfCertificateList (ASN1CTXT *pctxt, ASN1T__SeqOfCertificateList* pSrcValue, ASN1T__SeqOfCertificateList* pDstValue);

EXTERN void asn1Free__SeqOfCertificateList (ASN1CTXT *pctxt, ASN1T__SeqOfCertificateList* pvalue);

/**************************************************************/
/*                                                            */
/*  _SeqOfBasicOCSPResponse                                   */
/*                                                            */
/**************************************************************/

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

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

   ASN1C__SeqOfBasicOCSPResponse& operator= (ASN1C__SeqOfBasicOCSPResponse& srcData);
   void Append (ASN1T_BasicOCSPResponse * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SeqOfBasicOCSPResponse (ASN1CTXT* pctxt,
   ASN1T__SeqOfBasicOCSPResponse *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfBasicOCSPResponse (ASN1CTXT* pctxt,
   ASN1T__SeqOfBasicOCSPResponse *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfBasicOCSPResponse (ASN1CTXT *pctxt, ASN1T__SeqOfBasicOCSPResponse* pSrcValue, ASN1T__SeqOfBasicOCSPResponse* pDstValue);

EXTERN void asn1Free__SeqOfBasicOCSPResponse (ASN1CTXT *pctxt, ASN1T__SeqOfBasicOCSPResponse* pvalue);

/**************************************************************/
/*                                                            */
/*  RevocationValues                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_RevocationValues;

typedef struct EXTERN ASN1T_RevocationValues : public ASN1TPDU {
   struct {
      unsigned crlValsPresent : 1;
      unsigned ocspValsPresent : 1;
   } m;
   ASN1T__SeqOfCertificateList crlVals;
   ASN1T__SeqOfBasicOCSPResponse ocspVals;
   ASN1T_RevocationValues ();
   ASN1T_RevocationValues (ASN1C_RevocationValues& srcData);
   ~ASN1T_RevocationValues ();
} ASN1T_RevocationValues;

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

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

EXTERN int asn1E_RevocationValues (ASN1CTXT* pctxt,
   ASN1T_RevocationValues *pvalue, ASN1TagType tagging);

EXTERN int asn1D_RevocationValues (ASN1CTXT* pctxt,
   ASN1T_RevocationValues *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_RevocationValues (ASN1CTXT *pctxt, ASN1T_RevocationValues* pSrcValue, ASN1T_RevocationValues* pDstValue);

EXTERN void asn1Free_RevocationValues (ASN1CTXT *pctxt, ASN1T_RevocationValues* pvalue);

/**************************************************************/
/*                                                            */
/*  SigPolicyQualifierInfo                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SigPolicyQualifierInfo;

typedef struct EXTERN ASN1T_SigPolicyQualifierInfo : public ASN1TPDU {
   struct {
      unsigned qualifierPresent : 1;
   } m;
   ASN1TObjId sigPolicyQualifierId;
   Asn1TObject qualifier;
   ASN1T_SigPolicyQualifierInfo ();
   ASN1T_SigPolicyQualifierInfo (ASN1C_SigPolicyQualifierInfo& srcData);
   ~ASN1T_SigPolicyQualifierInfo ();
} ASN1T_SigPolicyQualifierInfo;

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

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

EXTERN int asn1E_SigPolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_SigPolicyQualifierInfo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SigPolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_SigPolicyQualifierInfo *pvalue, ASN1TagType tagging, int length);

EXTERN int asn1XETC_SigPolicyQualifierInfo (ASN1CTXT* pctxt,
    ASN1T_SigPolicyQualifierInfo *pvalue);

EXTERN int asn1XDTC_SigPolicyQualifierInfo (ASN1CtxtPtr& pctxt,
    ASN1T_SigPolicyQualifierInfo *pvalue);

EXTERN int asn1ETC_SigPolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_SigPolicyQualifierInfo *pvalue);

EXTERN int asn1DTC_SigPolicyQualifierInfo (ASN1CTXT* pctxt,
   ASN1T_SigPolicyQualifierInfo *pvalue);

EXTERN void asn1Copy_SigPolicyQualifierInfo (ASN1CTXT *pctxt, ASN1T_SigPolicyQualifierInfo* pSrcValue, ASN1T_SigPolicyQualifierInfo* pDstValue);

EXTERN void asn1Free_SigPolicyQualifierInfo (ASN1CTXT *pctxt, ASN1T_SigPolicyQualifierInfo* pvalue);

/**************************************************************/
/*                                                            */
/*  SignaturePolicyId_sigPolicyQualifiers                     */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_SignaturePolicyId_sigPolicyQualifiers& operator= (ASN1C_SignaturePolicyId_sigPolicyQualifiers& srcData);
   void Append (ASN1T_SigPolicyQualifierInfo * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_SignaturePolicyId_sigPolicyQualifiers (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicyId_sigPolicyQualifiers *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignaturePolicyId_sigPolicyQualifiers (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicyId_sigPolicyQualifiers *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignaturePolicyId_sigPolicyQualifiers (ASN1CTXT *pctxt, ASN1T_SignaturePolicyId_sigPolicyQualifiers* pSrcValue, ASN1T_SignaturePolicyId_sigPolicyQualifiers* pDstValue);

EXTERN void asn1Free_SignaturePolicyId_sigPolicyQualifiers (ASN1CTXT *pctxt, ASN1T_SignaturePolicyId_sigPolicyQualifiers* pvalue);

/**************************************************************/
/*                                                            */
/*  SignaturePolicyId                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SignaturePolicyId;

typedef struct EXTERN ASN1T_SignaturePolicyId : public ASN1TPDU {
   struct {
      unsigned sigPolicyQualifiersPresent : 1;
   } m;
   ASN1T_SigPolicyId sigPolicyIdentifier;
   ASN1T_SigPolicyHash sigPolicyHash;
   ASN1T_SignaturePolicyId_sigPolicyQualifiers sigPolicyQualifiers;
   ASN1T_SignaturePolicyId ();
   ASN1T_SignaturePolicyId (ASN1C_SignaturePolicyId& srcData);
   ~ASN1T_SignaturePolicyId ();
} ASN1T_SignaturePolicyId;

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

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

EXTERN int asn1E_SignaturePolicyId (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicyId *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignaturePolicyId (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicyId *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignaturePolicyId (ASN1CTXT *pctxt, ASN1T_SignaturePolicyId* pSrcValue, ASN1T_SignaturePolicyId* pDstValue);

EXTERN void asn1Free_SignaturePolicyId (ASN1CTXT *pctxt, ASN1T_SignaturePolicyId* pvalue);

/**************************************************************/
/*                                                            */
/*  SignaturePolicy                                           */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_SignaturePolicy_signaturePolicyImplied 1
#define T_SignaturePolicy_signaturePolicyId 2

class EXTERN ASN1C_SignaturePolicy;

typedef struct EXTERN ASN1T_SignaturePolicy : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      /* t = 2 */
      ASN1T_SignaturePolicyId *signaturePolicyId;
   } u;
   ASN1T_SignaturePolicy () {}
   ASN1T_SignaturePolicy (ASN1C_SignaturePolicy& srcData);
   ~ASN1T_SignaturePolicy ();
} ASN1T_SignaturePolicy;

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

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

EXTERN int asn1E_SignaturePolicy (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicy *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignaturePolicy (ASN1CTXT* pctxt,
   ASN1T_SignaturePolicy *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignaturePolicy (ASN1CTXT *pctxt, ASN1T_SignaturePolicy* pSrcValue, ASN1T_SignaturePolicy* pDstValue);

EXTERN void asn1Free_SignaturePolicy (ASN1CTXT *pctxt, ASN1T_SignaturePolicy* pvalue);

/**************************************************************/
/*                                                            */
/*  CertifiedAttributes                                       */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CertifiedAttributes;

typedef ASN1T_AttributeCertificate ASN1T_CertifiedAttributes;

class EXTERN ASN1C_CertifiedAttributes :
   public ASN1C_AttributeCertificate
{
protected:
public:
   ASN1C_CertifiedAttributes (ASN1T_CertifiedAttributes& data);
   ASN1C_CertifiedAttributes (
      ASN1MessageBufferIF& msgBuf, ASN1T_CertifiedAttributes& data);
   ASN1C_CertifiedAttributes (ASN1C_CertifiedAttributes& 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_CertifiedAttributes& getCopy (ASN1T_CertifiedAttributes* pDstData = 0);
   ASN1T_CertifiedAttributes* newCopy ();

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

EXTERN int asn1E_CertifiedAttributes (ASN1CTXT* pctxt,
   ASN1T_CertifiedAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CertifiedAttributes (ASN1CTXT* pctxt,
   ASN1T_CertifiedAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CertifiedAttributes (ASN1CTXT *pctxt, ASN1T_CertifiedAttributes* pSrcValue, ASN1T_CertifiedAttributes* pDstValue);

EXTERN void asn1Free_CertifiedAttributes (ASN1CTXT *pctxt, ASN1T_CertifiedAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  ContentTimestamp                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ContentTimestamp;

typedef ASN1T_TimeStampToken ASN1T_ContentTimestamp;

class EXTERN ASN1C_ContentTimestamp :
   public ASN1C_TimeStampToken
{
protected:
public:
   ASN1C_ContentTimestamp (ASN1T_ContentTimestamp& data);
   ASN1C_ContentTimestamp (
      ASN1MessageBufferIF& msgBuf, ASN1T_ContentTimestamp& data);
   ASN1C_ContentTimestamp (ASN1C_ContentTimestamp& 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_ContentTimestamp& getCopy (ASN1T_ContentTimestamp* pDstData = 0);
   ASN1T_ContentTimestamp* newCopy ();

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

EXTERN int asn1E_ContentTimestamp (ASN1CTXT* pctxt,
   ASN1T_ContentTimestamp *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ContentTimestamp (ASN1CTXT* pctxt,
   ASN1T_ContentTimestamp *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ContentTimestamp (ASN1CTXT *pctxt, ASN1T_ContentTimestamp* pSrcValue, ASN1T_ContentTimestamp* pDstValue);

EXTERN void asn1Free_ContentTimestamp (ASN1CTXT *pctxt, ASN1T_ContentTimestamp* pvalue);

/**************************************************************/
/*                                                            */
/*  SignatureTimeStampToken                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SignatureTimeStampToken;

typedef ASN1T_TimeStampToken ASN1T_SignatureTimeStampToken;

class EXTERN ASN1C_SignatureTimeStampToken :
   public ASN1C_TimeStampToken
{
protected:
public:
   ASN1C_SignatureTimeStampToken (ASN1T_SignatureTimeStampToken& data);
   ASN1C_SignatureTimeStampToken (
      ASN1MessageBufferIF& msgBuf, ASN1T_SignatureTimeStampToken& data);
   ASN1C_SignatureTimeStampToken (ASN1C_SignatureTimeStampToken& 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_SignatureTimeStampToken& getCopy (ASN1T_SignatureTimeStampToken* pDstData = 0);
   ASN1T_SignatureTimeStampToken* newCopy ();

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

EXTERN int asn1E_SignatureTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_SignatureTimeStampToken *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignatureTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_SignatureTimeStampToken *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignatureTimeStampToken (ASN1CTXT *pctxt, ASN1T_SignatureTimeStampToken* pSrcValue, ASN1T_SignatureTimeStampToken* pDstValue);

EXTERN void asn1Free_SignatureTimeStampToken (ASN1CTXT *pctxt, ASN1T_SignatureTimeStampToken* pvalue);

/**************************************************************/
/*                                                            */
/*  ESCTimeStampToken                                         */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ESCTimeStampToken;

typedef ASN1T_TimeStampToken ASN1T_ESCTimeStampToken;

class EXTERN ASN1C_ESCTimeStampToken :
   public ASN1C_TimeStampToken
{
protected:
public:
   ASN1C_ESCTimeStampToken (ASN1T_ESCTimeStampToken& data);
   ASN1C_ESCTimeStampToken (
      ASN1MessageBufferIF& msgBuf, ASN1T_ESCTimeStampToken& data);
   ASN1C_ESCTimeStampToken (ASN1C_ESCTimeStampToken& 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_ESCTimeStampToken& getCopy (ASN1T_ESCTimeStampToken* pDstData = 0);
   ASN1T_ESCTimeStampToken* newCopy ();

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

EXTERN int asn1E_ESCTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_ESCTimeStampToken *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESCTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_ESCTimeStampToken *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ESCTimeStampToken (ASN1CTXT *pctxt, ASN1T_ESCTimeStampToken* pSrcValue, ASN1T_ESCTimeStampToken* pDstValue);

EXTERN void asn1Free_ESCTimeStampToken (ASN1CTXT *pctxt, ASN1T_ESCTimeStampToken* pvalue);

/**************************************************************/
/*                                                            */
/*  TimestampedCertsCRLs                                      */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_TimestampedCertsCRLs;

typedef ASN1T_TimeStampToken ASN1T_TimestampedCertsCRLs;

class EXTERN ASN1C_TimestampedCertsCRLs :
   public ASN1C_TimeStampToken
{
protected:
public:
   ASN1C_TimestampedCertsCRLs (ASN1T_TimestampedCertsCRLs& data);
   ASN1C_TimestampedCertsCRLs (
      ASN1MessageBufferIF& msgBuf, ASN1T_TimestampedCertsCRLs& data);
   ASN1C_TimestampedCertsCRLs (ASN1C_TimestampedCertsCRLs& 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_TimestampedCertsCRLs& getCopy (ASN1T_TimestampedCertsCRLs* pDstData = 0);
   ASN1T_TimestampedCertsCRLs* newCopy ();

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

EXTERN int asn1E_TimestampedCertsCRLs (ASN1CTXT* pctxt,
   ASN1T_TimestampedCertsCRLs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_TimestampedCertsCRLs (ASN1CTXT* pctxt,
   ASN1T_TimestampedCertsCRLs *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_TimestampedCertsCRLs (ASN1CTXT *pctxt, ASN1T_TimestampedCertsCRLs* pSrcValue, ASN1T_TimestampedCertsCRLs* pDstValue);

EXTERN void asn1Free_TimestampedCertsCRLs (ASN1CTXT *pctxt, ASN1T_TimestampedCertsCRLs* pvalue);

/**************************************************************/
/*                                                            */
/*  ArchiveTimeStampToken                                     */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ArchiveTimeStampToken;

typedef ASN1T_TimeStampToken ASN1T_ArchiveTimeStampToken;

class EXTERN ASN1C_ArchiveTimeStampToken :
   public ASN1C_TimeStampToken
{
protected:
public:
   ASN1C_ArchiveTimeStampToken (ASN1T_ArchiveTimeStampToken& data);
   ASN1C_ArchiveTimeStampToken (
      ASN1MessageBufferIF& msgBuf, ASN1T_ArchiveTimeStampToken& data);
   ASN1C_ArchiveTimeStampToken (ASN1C_ArchiveTimeStampToken& 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_ArchiveTimeStampToken& getCopy (ASN1T_ArchiveTimeStampToken* pDstData = 0);
   ASN1T_ArchiveTimeStampToken* newCopy ();

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

EXTERN int asn1E_ArchiveTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_ArchiveTimeStampToken *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ArchiveTimeStampToken (ASN1CTXT* pctxt,
   ASN1T_ArchiveTimeStampToken *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ArchiveTimeStampToken (ASN1CTXT *pctxt, ASN1T_ArchiveTimeStampToken* pSrcValue, ASN1T_ArchiveTimeStampToken* pDstValue);

EXTERN void asn1Free_ArchiveTimeStampToken (ASN1CTXT *pctxt, ASN1T_ArchiveTimeStampToken* pvalue);

/**************************************************************/
/*                                                            */
/*  DisplayText                                               */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_DisplayText_utf8String        1
#define T_DisplayText_visibleString     2
#define T_DisplayText_bmpString         3

class EXTERN ASN1C_DisplayText;

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

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

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

EXTERN int asn1E_DisplayText (ASN1CTXT* pctxt,
   ASN1T_DisplayText *pvalue, ASN1TagType tagging);

EXTERN int asn1D_DisplayText (ASN1CTXT* pctxt,
   ASN1T_DisplayText *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_DisplayText (ASN1CTXT *pctxt, ASN1T_DisplayText* pSrcValue, ASN1T_DisplayText* pDstValue);

EXTERN void asn1Free_DisplayText (ASN1CTXT *pctxt, ASN1T_DisplayText* pvalue);

/**************************************************************/
/*                                                            */
/*  NoticeReference_noticeNumbers                             */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_NoticeReference_noticeNumbers;

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

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

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

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

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

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

EXTERN int asn1E_NoticeReference_noticeNumbers (ASN1CTXT* pctxt,
   ASN1T_NoticeReference_noticeNumbers *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NoticeReference_noticeNumbers (ASN1CTXT* pctxt,
   ASN1T_NoticeReference_noticeNumbers *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_NoticeReference_noticeNumbers (ASN1CTXT *pctxt, ASN1T_NoticeReference_noticeNumbers* pSrcValue, ASN1T_NoticeReference_noticeNumbers* pDstValue);

EXTERN void asn1Free_NoticeReference_noticeNumbers (ASN1CTXT *pctxt, ASN1T_NoticeReference_noticeNumbers* pvalue);

/**************************************************************/
/*                                                            */
/*  NoticeReference                                           */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_NoticeReference;

typedef struct EXTERN ASN1T_NoticeReference : public ASN1TPDU {
   ASN1T_DisplayText organization;
   ASN1T_NoticeReference_noticeNumbers noticeNumbers;
   ASN1T_NoticeReference ();
   ASN1T_NoticeReference (ASN1C_NoticeReference& srcData);
   ~ASN1T_NoticeReference ();
} ASN1T_NoticeReference;

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

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

EXTERN int asn1E_NoticeReference (ASN1CTXT* pctxt,
   ASN1T_NoticeReference *pvalue, ASN1TagType tagging);

EXTERN int asn1D_NoticeReference (ASN1CTXT* pctxt,
   ASN1T_NoticeReference *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_NoticeReference (ASN1CTXT *pctxt, ASN1T_NoticeReference* pSrcValue, ASN1T_NoticeReference* pDstValue);

EXTERN void asn1Free_NoticeReference (ASN1CTXT *pctxt, ASN1T_NoticeReference* pvalue);

/**************************************************************/
/*                                                            */
/*  SPUserNotice                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SPUserNotice;

typedef struct EXTERN ASN1T_SPUserNotice : public ASN1TPDU {
   struct {
      unsigned noticeRefPresent : 1;
      unsigned explicitTextPresent : 1;
   } m;
   ASN1T_NoticeReference noticeRef;
   ASN1T_DisplayText explicitText;
   ASN1T_SPUserNotice ();
   ASN1T_SPUserNotice (ASN1C_SPUserNotice& srcData);
   ~ASN1T_SPUserNotice ();
} ASN1T_SPUserNotice;

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

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

EXTERN int asn1E_SPUserNotice (ASN1CTXT* pctxt,
   ASN1T_SPUserNotice *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SPUserNotice (ASN1CTXT* pctxt,
   ASN1T_SPUserNotice *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SPUserNotice (ASN1CTXT *pctxt, ASN1T_SPUserNotice* pSrcValue, ASN1T_SPUserNotice* pDstValue);

EXTERN void asn1Free_SPUserNotice (ASN1CTXT *pctxt, ASN1T_SPUserNotice* pvalue);

/**************************************************************/
/*                                                            */
/*  CommitmentTypeQualifier                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CommitmentTypeQualifier;

typedef struct EXTERN ASN1T_CommitmentTypeQualifier : public ASN1TPDU {
   struct {
      unsigned qualifierPresent : 1;
   } m;
   ASN1TObjId commitmentQualifierId;
   ASN1TOpenType qualifier;
   ASN1T_CommitmentTypeQualifier ();
   ASN1T_CommitmentTypeQualifier (ASN1C_CommitmentTypeQualifier& srcData);
   ~ASN1T_CommitmentTypeQualifier ();
} ASN1T_CommitmentTypeQualifier;

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

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

EXTERN int asn1E_CommitmentTypeQualifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeQualifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CommitmentTypeQualifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeQualifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CommitmentTypeQualifier (ASN1CTXT *pctxt, ASN1T_CommitmentTypeQualifier* pSrcValue, ASN1T_CommitmentTypeQualifier* pDstValue);

EXTERN void asn1Free_CommitmentTypeQualifier (ASN1CTXT *pctxt, ASN1T_CommitmentTypeQualifier* pvalue);

/**************************************************************/
/*                                                            */
/*  CommitmentTypeIndication_commitmentTypeQualifier          */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_CommitmentTypeIndication_commitmentTypeQualifier& operator= (ASN1C_CommitmentTypeIndication_commitmentTypeQualifier& srcData);
   void Append (ASN1T_CommitmentTypeQualifier * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_CommitmentTypeIndication_commitmentTypeQualifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIndication_commitmentTypeQualifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CommitmentTypeIndication_commitmentTypeQualifier (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIndication_commitmentTypeQualifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CommitmentTypeIndication_commitmentTypeQualifier (ASN1CTXT *pctxt, ASN1T_CommitmentTypeIndication_commitmentTypeQualifier* pSrcValue, ASN1T_CommitmentTypeIndication_commitmentTypeQualifier* pDstValue);

EXTERN void asn1Free_CommitmentTypeIndication_commitmentTypeQualifier (ASN1CTXT *pctxt, ASN1T_CommitmentTypeIndication_commitmentTypeQualifier* pvalue);

/**************************************************************/
/*                                                            */
/*  CommitmentTypeIndication                                  */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_CommitmentTypeIndication;

typedef struct EXTERN ASN1T_CommitmentTypeIndication : public ASN1TPDU {
   struct {
      unsigned commitmentTypeQualifierPresent : 1;
   } m;
   ASN1T_CommitmentTypeIdentifier commitmentTypeId;
   ASN1T_CommitmentTypeIndication_commitmentTypeQualifier commitmentTypeQualifier;
   ASN1T_CommitmentTypeIndication ();
   ASN1T_CommitmentTypeIndication (ASN1C_CommitmentTypeIndication& srcData);
   ~ASN1T_CommitmentTypeIndication ();
} ASN1T_CommitmentTypeIndication;

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

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

EXTERN int asn1E_CommitmentTypeIndication (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIndication *pvalue, ASN1TagType tagging);

EXTERN int asn1D_CommitmentTypeIndication (ASN1CTXT* pctxt,
   ASN1T_CommitmentTypeIndication *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_CommitmentTypeIndication (ASN1CTXT *pctxt, ASN1T_CommitmentTypeIndication* pSrcValue, ASN1T_CommitmentTypeIndication* pDstValue);

EXTERN void asn1Free_CommitmentTypeIndication (ASN1CTXT *pctxt, ASN1T_CommitmentTypeIndication* pvalue);

/**************************************************************/
/*                                                            */
/*  SignerLocation_countryName                                */
/*                                                            */
/**************************************************************/

#define TV_SignerLocation_countryName	(TM_CTXT|TM_CONS|0)

/* Choice tag constants */

#define T_SignerLocation_countryName_utf8String 1
#define T_SignerLocation_countryName_printableString 2
#define T_SignerLocation_countryName_teletexString 3
#define T_SignerLocation_countryName_universalString 4
#define T_SignerLocation_countryName_bmpString 5

class EXTERN ASN1C_SignerLocation_countryName;

typedef struct EXTERN ASN1T_SignerLocation_countryName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1PrintableString printableString;
      /* t = 3 */
      ASN1T61String teletexString;
      /* t = 4 */
      ASN1UniversalString universalString;
      /* t = 5 */
      ASN1BMPString bmpString;
   } u;
   ASN1T_SignerLocation_countryName () {}
   ASN1T_SignerLocation_countryName (ASN1C_SignerLocation_countryName& srcData);
   ~ASN1T_SignerLocation_countryName ();
} ASN1T_SignerLocation_countryName;

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

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

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

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

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

EXTERN int asn1E_SignerLocation_countryName (ASN1CTXT* pctxt,
   ASN1T_SignerLocation_countryName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignerLocation_countryName (ASN1CTXT* pctxt,
   ASN1T_SignerLocation_countryName *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignerLocation_countryName (ASN1CTXT *pctxt, ASN1T_SignerLocation_countryName* pSrcValue, ASN1T_SignerLocation_countryName* pDstValue);

EXTERN void asn1Free_SignerLocation_countryName (ASN1CTXT *pctxt, ASN1T_SignerLocation_countryName* pvalue);

/**************************************************************/
/*                                                            */
/*  SignerLocation_localityName                               */
/*                                                            */
/**************************************************************/

#define TV_SignerLocation_localityName	(TM_CTXT|TM_CONS|1)

/* Choice tag constants */

#define T_SignerLocation_localityName_utf8String 1
#define T_SignerLocation_localityName_printableString 2
#define T_SignerLocation_localityName_teletexString 3
#define T_SignerLocation_localityName_universalString 4
#define T_SignerLocation_localityName_bmpString 5

class EXTERN ASN1C_SignerLocation_localityName;

typedef struct EXTERN ASN1T_SignerLocation_localityName : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1PrintableString printableString;
      /* t = 3 */
      ASN1T61String teletexString;
      /* t = 4 */
      ASN1UniversalString universalString;
      /* t = 5 */
      ASN1BMPString bmpString;
   } u;
   ASN1T_SignerLocation_localityName () {}
   ASN1T_SignerLocation_localityName (ASN1C_SignerLocation_localityName& srcData);
   ~ASN1T_SignerLocation_localityName ();
} ASN1T_SignerLocation_localityName;

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

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

EXTERN int asn1E_SignerLocation_localityName (ASN1CTXT* pctxt,
   ASN1T_SignerLocation_localityName *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignerLocation_localityName (ASN1CTXT* pctxt,
   ASN1T_SignerLocation_localityName *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignerLocation_localityName (ASN1CTXT *pctxt, ASN1T_SignerLocation_localityName* pSrcValue, ASN1T_SignerLocation_localityName* pDstValue);

EXTERN void asn1Free_SignerLocation_localityName (ASN1CTXT *pctxt, ASN1T_SignerLocation_localityName* pvalue);

/**************************************************************/
/*                                                            */
/*  SignerLocation                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SignerLocation;

typedef struct EXTERN ASN1T_SignerLocation : public ASN1TPDU {
   struct {
      unsigned countryNamePresent : 1;
      unsigned localityNamePresent : 1;
      unsigned postalAdddressPresent : 1;
   } m;
   ASN1T_SignerLocation_countryName countryName;
   ASN1T_SignerLocation_localityName localityName;
   ASN1T_PostalAddress postalAdddress;
   ASN1T_SignerLocation ();
   ASN1T_SignerLocation (ASN1C_SignerLocation& srcData);
   ~ASN1T_SignerLocation ();
} ASN1T_SignerLocation;

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

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

EXTERN int asn1E_SignerLocation (ASN1CTXT* pctxt,
   ASN1T_SignerLocation *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignerLocation (ASN1CTXT* pctxt,
   ASN1T_SignerLocation *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignerLocation (ASN1CTXT *pctxt, ASN1T_SignerLocation* pSrcValue, ASN1T_SignerLocation* pDstValue);

EXTERN void asn1Free_SignerLocation (ASN1CTXT *pctxt, ASN1T_SignerLocation* pvalue);

/**************************************************************/
/*                                                            */
/*  ClaimedAttributes                                         */
/*                                                            */
/**************************************************************/

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

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

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

EXTERN int asn1E_ClaimedAttributes (ASN1CTXT* pctxt,
   ASN1T_ClaimedAttributes *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ClaimedAttributes (ASN1CTXT* pctxt,
   ASN1T_ClaimedAttributes *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ClaimedAttributes (ASN1CTXT *pctxt, ASN1T_ClaimedAttributes* pSrcValue, ASN1T_ClaimedAttributes* pDstValue);

EXTERN void asn1Free_ClaimedAttributes (ASN1CTXT *pctxt, ASN1T_ClaimedAttributes* pvalue);

/**************************************************************/
/*                                                            */
/*  SignerAttribute_element                                   */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_SignerAttribute_element_claimedAttributes 1
#define T_SignerAttribute_element_certifiedAttributes 2

class EXTERN ASN1C_SignerAttribute_element;

typedef struct EXTERN ASN1T_SignerAttribute_element : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_ClaimedAttributes *claimedAttributes;
      /* t = 2 */
      ASN1T_CertifiedAttributes *certifiedAttributes;
   } u;
   ASN1T_SignerAttribute_element () {}
   ASN1T_SignerAttribute_element (ASN1C_SignerAttribute_element& srcData);
   ~ASN1T_SignerAttribute_element ();
} ASN1T_SignerAttribute_element;

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

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

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

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

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

EXTERN int asn1E_SignerAttribute_element (ASN1CTXT* pctxt,
   ASN1T_SignerAttribute_element *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignerAttribute_element (ASN1CTXT* pctxt,
   ASN1T_SignerAttribute_element *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignerAttribute_element (ASN1CTXT *pctxt, ASN1T_SignerAttribute_element* pSrcValue, ASN1T_SignerAttribute_element* pDstValue);

EXTERN void asn1Free_SignerAttribute_element (ASN1CTXT *pctxt, ASN1T_SignerAttribute_element* pvalue);

/**************************************************************/
/*                                                            */
/*  SignerAttribute                                           */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_SignerAttribute& operator= (ASN1C_SignerAttribute& srcData);
   void Append (ASN1T_SignerAttribute_element * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_SignerAttribute (ASN1CTXT* pctxt,
   ASN1T_SignerAttribute *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SignerAttribute (ASN1CTXT* pctxt,
   ASN1T_SignerAttribute *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SignerAttribute (ASN1CTXT *pctxt, ASN1T_SignerAttribute* pSrcValue, ASN1T_SignerAttribute* pDstValue);

EXTERN void asn1Free_SignerAttribute (ASN1CTXT *pctxt, ASN1T_SignerAttribute* pvalue);

/**************************************************************/
/*                                                            */
/*  OtherRevRefs                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_OtherRevRefs;

typedef struct EXTERN ASN1T_OtherRevRefs : public ASN1TPDU {
   ASN1TObjId otherRevRefType;
   ASN1TOpenType otherRevRefs;
   ASN1T_OtherRevRefs ();
   ASN1T_OtherRevRefs (ASN1C_OtherRevRefs& srcData);
   ~ASN1T_OtherRevRefs ();
} ASN1T_OtherRevRefs;

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

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

EXTERN int asn1E_OtherRevRefs (ASN1CTXT* pctxt,
   ASN1T_OtherRevRefs *pvalue, ASN1TagType tagging);

EXTERN int asn1D_OtherRevRefs (ASN1CTXT* pctxt,
   ASN1T_OtherRevRefs *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_OtherRevRefs (ASN1CTXT *pctxt, ASN1T_OtherRevRefs* pSrcValue, ASN1T_OtherRevRefs* pDstValue);

EXTERN void asn1Free_OtherRevRefs (ASN1CTXT *pctxt, ASN1T_OtherRevRefs* pvalue);

/* Value definitions */

extern EXTERN ASN1OBJID id_etsi_es_IDUP_Mechanism_v1;
extern EXTERN ASN1OBJID id_aa_ets_sigPolicyId;
extern EXTERN ASN1OBJID id_spq_ets_uri;
extern EXTERN ASN1OBJID id_spq_ets_unotice;
extern EXTERN ASN1OBJID id_aa_ets_commitmentType;
extern EXTERN ASN1OBJID id_cti_ets_proofOfOrigin;
extern EXTERN ASN1OBJID id_cti_ets_proofOfReceipt;
extern EXTERN ASN1OBJID id_cti_ets_proofOfDelivery;
extern EXTERN ASN1OBJID id_cti_ets_proofOfSender;
extern EXTERN ASN1OBJID id_cti_ets_proofOfApproval;
extern EXTERN ASN1OBJID id_cti_ets_proofOfCreation;
extern EXTERN ASN1OBJID id_aa_ets_signerLocation;
extern EXTERN ASN1OBJID id_aa_ets_signerAttr;
extern EXTERN ASN1OBJID id_aa_ets_contentTimestamp;
extern EXTERN ASN1OBJID id_aa_signatureTimeStampToken;
extern EXTERN ASN1OBJID id_aa_ets_certificateRefs;
extern EXTERN ASN1OBJID id_aa_ets_revocationRefs;
extern EXTERN ASN1OBJID id_aa_ets_certValues;
extern EXTERN ASN1OBJID id_aa_ets_revocationValues;
extern EXTERN ASN1OBJID id_aa_ets_escTimeStamp;
extern EXTERN ASN1OBJID id_aa_ets_certCRLTimestamp;
extern EXTERN ASN1OBJID id_aa_ets_archiveTimestamp;

}
#endif
