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

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

/**************************************************************/
/*                                                            */
/*  ContentIdentifier                                         */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_ContentIdentifier;

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

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

EXTERN int asn1E_ContentIdentifier (ASN1CTXT* pctxt,
   ASN1T_ContentIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ContentIdentifier (ASN1CTXT* pctxt,
   ASN1T_ContentIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ContentIdentifier (ASN1CTXT *pctxt, ASN1T_ContentIdentifier* pSrcValue, ASN1T_ContentIdentifier* pDstValue);

EXTERN void asn1Free_ContentIdentifier (ASN1CTXT *pctxt, ASN1T_ContentIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  AllOrFirstTier                                            */
/*                                                            */
/**************************************************************/

struct EXTERN AllOrFirstTier {
   enum Root {
      allReceipts = 0,
      firstTierRecipients = 1
   } ;
} ;

typedef ASN1UINT ASN1T_AllOrFirstTier;

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

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

EXTERN int asn1E_AllOrFirstTier (ASN1CTXT* pctxt,
   ASN1T_AllOrFirstTier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_AllOrFirstTier (ASN1CTXT* pctxt,
   ASN1T_AllOrFirstTier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_AllOrFirstTier (ASN1CTXT *pctxt, ASN1T_AllOrFirstTier* pSrcValue, ASN1T_AllOrFirstTier* pDstValue);

/**************************************************************/
/*                                                            */
/*  ESSVersion                                                */
/*                                                            */
/**************************************************************/

struct EXTERN ESSVersion {
   enum Root {
      v1 = 1
   } ;
} ;

typedef ASN1UINT ASN1T_ESSVersion;

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

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

EXTERN int asn1E_ESSVersion (ASN1CTXT* pctxt,
   ASN1T_ESSVersion *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESSVersion (ASN1CTXT* pctxt,
   ASN1T_ESSVersion *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ESSVersion (ASN1CTXT *pctxt, ASN1T_ESSVersion* pSrcValue, ASN1T_ESSVersion* pDstValue);

/**************************************************************/
/*                                                            */
/*  MsgSigDigest                                              */
/*                                                            */
/**************************************************************/

typedef ASN1TDynOctStr ASN1T_MsgSigDigest;

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

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

EXTERN int asn1E_MsgSigDigest (ASN1CTXT* pctxt,
   ASN1T_MsgSigDigest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MsgSigDigest (ASN1CTXT* pctxt,
   ASN1T_MsgSigDigest *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MsgSigDigest (ASN1CTXT *pctxt, ASN1T_MsgSigDigest* pSrcValue, ASN1T_MsgSigDigest* pDstValue);

EXTERN void asn1Free_MsgSigDigest (ASN1CTXT *pctxt, ASN1T_MsgSigDigest* pvalue);

/**************************************************************/
/*                                                            */
/*  SecurityPolicyIdentifier                                  */
/*                                                            */
/**************************************************************/

typedef ASN1TObjId ASN1T_SecurityPolicyIdentifier;

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

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

EXTERN int asn1E_SecurityPolicyIdentifier (ASN1CTXT* pctxt,
   ASN1T_SecurityPolicyIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SecurityPolicyIdentifier (ASN1CTXT* pctxt,
   ASN1T_SecurityPolicyIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SecurityPolicyIdentifier (ASN1CTXT *pctxt, ASN1T_SecurityPolicyIdentifier* pSrcValue, ASN1T_SecurityPolicyIdentifier* pDstValue);

/**************************************************************/
/*                                                            */
/*  SecurityClassification                                    */
/*                                                            */
/**************************************************************/

struct EXTERN SecurityClassification {
   enum Root {
      unmarked = 0,
      unclassified = 1,
      restricted = 2,
      confidential = 3,
      secret = 4,
      top_secret = 5
   } ;
} ;

typedef ASN1USINT ASN1T_SecurityClassification;

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

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

EXTERN int asn1E_SecurityClassification (ASN1CTXT* pctxt,
   ASN1T_SecurityClassification *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SecurityClassification (ASN1CTXT* pctxt,
   ASN1T_SecurityClassification *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SecurityClassification (ASN1CTXT *pctxt, ASN1T_SecurityClassification* pSrcValue, ASN1T_SecurityClassification* pDstValue);

/**************************************************************/
/*                                                            */
/*  _SeqOfGeneralNames                                        */
/*                                                            */
/**************************************************************/

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

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

   ASN1C__SeqOfGeneralNames& operator= (ASN1C__SeqOfGeneralNames& srcData);
   void Append (ASN1T_GeneralNames * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E__SeqOfGeneralNames (ASN1CTXT* pctxt,
   ASN1T__SeqOfGeneralNames *pvalue, ASN1TagType tagging);

EXTERN int asn1D__SeqOfGeneralNames (ASN1CTXT* pctxt,
   ASN1T__SeqOfGeneralNames *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy__SeqOfGeneralNames (ASN1CTXT *pctxt, ASN1T__SeqOfGeneralNames* pSrcValue, ASN1T__SeqOfGeneralNames* pDstValue);

EXTERN void asn1Free__SeqOfGeneralNames (ASN1CTXT *pctxt, ASN1T__SeqOfGeneralNames* pvalue);

/**************************************************************/
/*                                                            */
/*  ReceiptsFrom                                              */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_ReceiptsFrom_allOrFirstTier   1
#define T_ReceiptsFrom_receiptList      2

class EXTERN ASN1C_ReceiptsFrom;

typedef struct EXTERN ASN1T_ReceiptsFrom : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_AllOrFirstTier allOrFirstTier;
      /* t = 2 */
      ASN1T__SeqOfGeneralNames *receiptList;
   } u;
   ASN1T_ReceiptsFrom () {}
   ASN1T_ReceiptsFrom (ASN1C_ReceiptsFrom& srcData);
   ~ASN1T_ReceiptsFrom ();
} ASN1T_ReceiptsFrom;

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

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

EXTERN int asn1E_ReceiptsFrom (ASN1CTXT* pctxt,
   ASN1T_ReceiptsFrom *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ReceiptsFrom (ASN1CTXT* pctxt,
   ASN1T_ReceiptsFrom *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ReceiptsFrom (ASN1CTXT *pctxt, ASN1T_ReceiptsFrom* pSrcValue, ASN1T_ReceiptsFrom* pDstValue);

EXTERN void asn1Free_ReceiptsFrom (ASN1CTXT *pctxt, ASN1T_ReceiptsFrom* pvalue);

/**************************************************************/
/*                                                            */
/*  ReceiptRequest_receiptsTo                                 */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_ReceiptRequest_receiptsTo& operator= (ASN1C_ReceiptRequest_receiptsTo& srcData);
   void Append (ASN1T_GeneralNames * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_ReceiptRequest_receiptsTo (ASN1CTXT* pctxt,
   ASN1T_ReceiptRequest_receiptsTo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ReceiptRequest_receiptsTo (ASN1CTXT* pctxt,
   ASN1T_ReceiptRequest_receiptsTo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ReceiptRequest_receiptsTo (ASN1CTXT *pctxt, ASN1T_ReceiptRequest_receiptsTo* pSrcValue, ASN1T_ReceiptRequest_receiptsTo* pDstValue);

EXTERN void asn1Free_ReceiptRequest_receiptsTo (ASN1CTXT *pctxt, ASN1T_ReceiptRequest_receiptsTo* pvalue);

/**************************************************************/
/*                                                            */
/*  ReceiptRequest                                            */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ReceiptRequest;

typedef struct EXTERN ASN1T_ReceiptRequest : public ASN1TPDU {
   ASN1T_ContentIdentifier signedContentIdentifier;
   ASN1T_ReceiptsFrom receiptsFrom;
   ASN1T_ReceiptRequest_receiptsTo receiptsTo;
   ASN1T_ReceiptRequest ();
   ASN1T_ReceiptRequest (ASN1C_ReceiptRequest& srcData);
   ~ASN1T_ReceiptRequest ();
} ASN1T_ReceiptRequest;

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

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

EXTERN int asn1E_ReceiptRequest (ASN1CTXT* pctxt,
   ASN1T_ReceiptRequest *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ReceiptRequest (ASN1CTXT* pctxt,
   ASN1T_ReceiptRequest *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ReceiptRequest (ASN1CTXT *pctxt, ASN1T_ReceiptRequest* pSrcValue, ASN1T_ReceiptRequest* pDstValue);

EXTERN void asn1Free_ReceiptRequest (ASN1CTXT *pctxt, ASN1T_ReceiptRequest* pvalue);

/**************************************************************/
/*                                                            */
/*  Receipt                                                   */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_Receipt;

typedef struct EXTERN ASN1T_Receipt : public ASN1TPDU {
   ASN1T_ESSVersion version;
   ASN1T_ContentType contentType;
   ASN1T_ContentIdentifier signedContentIdentifier;
   ASN1TDynOctStr originatorSignatureValue;
   ASN1T_Receipt ();
   ASN1T_Receipt (ASN1C_Receipt& srcData);
   ~ASN1T_Receipt ();
} ASN1T_Receipt;

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

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

EXTERN int asn1E_Receipt (ASN1CTXT* pctxt,
   ASN1T_Receipt *pvalue, ASN1TagType tagging);

EXTERN int asn1D_Receipt (ASN1CTXT* pctxt,
   ASN1T_Receipt *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_Receipt (ASN1CTXT *pctxt, ASN1T_Receipt* pSrcValue, ASN1T_Receipt* pDstValue);

EXTERN void asn1Free_Receipt (ASN1CTXT *pctxt, ASN1T_Receipt* pvalue);

/**************************************************************/
/*                                                            */
/*  ContentHints                                              */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ContentHints;

typedef struct EXTERN ASN1T_ContentHints : public ASN1TPDU {
   struct {
      unsigned contentDescriptionPresent : 1;
   } m;
   ASN1UTF8String contentDescription;
   ASN1T_ContentType contentType;
   ASN1T_ContentHints ();
   ASN1T_ContentHints (ASN1C_ContentHints& srcData);
   ~ASN1T_ContentHints ();
} ASN1T_ContentHints;

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

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

EXTERN int asn1E_ContentHints (ASN1CTXT* pctxt,
   ASN1T_ContentHints *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ContentHints (ASN1CTXT* pctxt,
   ASN1T_ContentHints *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ContentHints (ASN1CTXT *pctxt, ASN1T_ContentHints* pSrcValue, ASN1T_ContentHints* pDstValue);

EXTERN void asn1Free_ContentHints (ASN1CTXT *pctxt, ASN1T_ContentHints* pvalue);

/**************************************************************/
/*                                                            */
/*  ContentReference                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ContentReference;

typedef struct EXTERN ASN1T_ContentReference : public ASN1TPDU {
   ASN1T_ContentType contentType;
   ASN1T_ContentIdentifier signedContentIdentifier;
   ASN1TDynOctStr originatorSignatureValue;
   ASN1T_ContentReference ();
   ASN1T_ContentReference (ASN1C_ContentReference& srcData);
   ~ASN1T_ContentReference ();
} ASN1T_ContentReference;

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

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

EXTERN int asn1E_ContentReference (ASN1CTXT* pctxt,
   ASN1T_ContentReference *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ContentReference (ASN1CTXT* pctxt,
   ASN1T_ContentReference *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ContentReference (ASN1CTXT *pctxt, ASN1T_ContentReference* pSrcValue, ASN1T_ContentReference* pDstValue);

EXTERN void asn1Free_ContentReference (ASN1CTXT *pctxt, ASN1T_ContentReference* pvalue);

/**************************************************************/
/*                                                            */
/*  ESSPrivacyMark                                            */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_ESSPrivacyMark_utf8String     1
#define T_ESSPrivacyMark_pString        2

class EXTERN ASN1C_ESSPrivacyMark;

typedef struct EXTERN ASN1T_ESSPrivacyMark : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1UTF8String utf8String;
      /* t = 2 */
      ASN1PrintableString pString;
   } u;
   ASN1T_ESSPrivacyMark () {}
   ASN1T_ESSPrivacyMark (ASN1C_ESSPrivacyMark& srcData);
   ~ASN1T_ESSPrivacyMark ();
} ASN1T_ESSPrivacyMark;

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

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

EXTERN int asn1E_ESSPrivacyMark (ASN1CTXT* pctxt,
   ASN1T_ESSPrivacyMark *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESSPrivacyMark (ASN1CTXT* pctxt,
   ASN1T_ESSPrivacyMark *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ESSPrivacyMark (ASN1CTXT *pctxt, ASN1T_ESSPrivacyMark* pSrcValue, ASN1T_ESSPrivacyMark* pDstValue);

EXTERN void asn1Free_ESSPrivacyMark (ASN1CTXT *pctxt, ASN1T_ESSPrivacyMark* pvalue);

/**************************************************************/
/*                                                            */
/*  SecurityCategory                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_SecurityCategory;

typedef struct EXTERN ASN1T_SecurityCategory : public ASN1TPDU {
   ASN1TObjId type;
   ASN1TOpenType value;
   ASN1T_SecurityCategory ();
   ASN1T_SecurityCategory (ASN1C_SecurityCategory& srcData);
   ~ASN1T_SecurityCategory ();
} ASN1T_SecurityCategory;

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

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

EXTERN int asn1E_SecurityCategory (ASN1CTXT* pctxt,
   ASN1T_SecurityCategory *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SecurityCategory (ASN1CTXT* pctxt,
   ASN1T_SecurityCategory *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SecurityCategory (ASN1CTXT *pctxt, ASN1T_SecurityCategory* pSrcValue, ASN1T_SecurityCategory* pDstValue);

EXTERN void asn1Free_SecurityCategory (ASN1CTXT *pctxt, ASN1T_SecurityCategory* pvalue);

/**************************************************************/
/*                                                            */
/*  SecurityCategories                                        */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_SecurityCategories& operator= (ASN1C_SecurityCategories& srcData);
   void Append (ASN1T_SecurityCategory * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_SecurityCategories (ASN1CTXT* pctxt,
   ASN1T_SecurityCategories *pvalue, ASN1TagType tagging);

EXTERN int asn1D_SecurityCategories (ASN1CTXT* pctxt,
   ASN1T_SecurityCategories *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_SecurityCategories (ASN1CTXT *pctxt, ASN1T_SecurityCategories* pSrcValue, ASN1T_SecurityCategories* pDstValue);

EXTERN void asn1Free_SecurityCategories (ASN1CTXT *pctxt, ASN1T_SecurityCategories* pvalue);

/**************************************************************/
/*                                                            */
/*  ESSSecurityLabel                                          */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_ESSSecurityLabel;

typedef struct EXTERN ASN1T_ESSSecurityLabel : public ASN1TPDU {
   struct {
      unsigned security_classificationPresent : 1;
      unsigned privacy_markPresent : 1;
      unsigned security_categoriesPresent : 1;
   } m;
   ASN1T_SecurityClassification security_classification;
   ASN1T_SecurityPolicyIdentifier security_policy_identifier;
   ASN1T_ESSPrivacyMark privacy_mark;
   ASN1T_SecurityCategories security_categories;
   ASN1T_ESSSecurityLabel ();
   ASN1T_ESSSecurityLabel (ASN1C_ESSSecurityLabel& srcData);
   ~ASN1T_ESSSecurityLabel ();
} ASN1T_ESSSecurityLabel;

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

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

EXTERN int asn1E_ESSSecurityLabel (ASN1CTXT* pctxt,
   ASN1T_ESSSecurityLabel *pvalue, ASN1TagType tagging);

EXTERN int asn1D_ESSSecurityLabel (ASN1CTXT* pctxt,
   ASN1T_ESSSecurityLabel *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_ESSSecurityLabel (ASN1CTXT *pctxt, ASN1T_ESSSecurityLabel* pSrcValue, ASN1T_ESSSecurityLabel* pDstValue);

EXTERN void asn1Free_ESSSecurityLabel (ASN1CTXT *pctxt, ASN1T_ESSSecurityLabel* pvalue);

/**************************************************************/
/*                                                            */
/*  EquivalentLabels                                          */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_EquivalentLabels& operator= (ASN1C_EquivalentLabels& srcData);
   void Append (ASN1T_ESSSecurityLabel * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_EquivalentLabels (ASN1CTXT* pctxt,
   ASN1T_EquivalentLabels *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EquivalentLabels (ASN1CTXT* pctxt,
   ASN1T_EquivalentLabels *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_EquivalentLabels (ASN1CTXT *pctxt, ASN1T_EquivalentLabels* pSrcValue, ASN1T_EquivalentLabels* pDstValue);

EXTERN void asn1Free_EquivalentLabels (ASN1CTXT *pctxt, ASN1T_EquivalentLabels* pvalue);

/**************************************************************/
/*                                                            */
/*  EntityIdentifier                                          */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_EntityIdentifier_subjectKeyIdentifier 1
#define T_EntityIdentifier_issuerAndSerialNumber 2

class EXTERN ASN1C_EntityIdentifier;

typedef struct EXTERN ASN1T_EntityIdentifier : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      ASN1T_SubjectKeyIdentifier *subjectKeyIdentifier;
      /* t = 2 */
      ASN1T_IssuerAndSerialNumber *issuerAndSerialNumber;
   } u;
   ASN1T_EntityIdentifier () {}
   ASN1T_EntityIdentifier (ASN1C_EntityIdentifier& srcData);
   ~ASN1T_EntityIdentifier ();
} ASN1T_EntityIdentifier;

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

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

EXTERN int asn1E_EntityIdentifier (ASN1CTXT* pctxt,
   ASN1T_EntityIdentifier *pvalue, ASN1TagType tagging);

EXTERN int asn1D_EntityIdentifier (ASN1CTXT* pctxt,
   ASN1T_EntityIdentifier *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_EntityIdentifier (ASN1CTXT *pctxt, ASN1T_EntityIdentifier* pSrcValue, ASN1T_EntityIdentifier* pDstValue);

EXTERN void asn1Free_EntityIdentifier (ASN1CTXT *pctxt, ASN1T_EntityIdentifier* pvalue);

/**************************************************************/
/*                                                            */
/*  MLReceiptPolicy_insteadOf                                 */
/*                                                            */
/**************************************************************/

#define TV_MLReceiptPolicy_insteadOf	(TM_CTXT|TM_CONS|1)

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

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

   ASN1C_MLReceiptPolicy_insteadOf& operator= (ASN1C_MLReceiptPolicy_insteadOf& srcData);
   void Append (ASN1T_GeneralNames * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_MLReceiptPolicy_insteadOf (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy_insteadOf *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MLReceiptPolicy_insteadOf (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy_insteadOf *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MLReceiptPolicy_insteadOf (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy_insteadOf* pSrcValue, ASN1T_MLReceiptPolicy_insteadOf* pDstValue);

EXTERN void asn1Free_MLReceiptPolicy_insteadOf (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy_insteadOf* pvalue);

/**************************************************************/
/*                                                            */
/*  MLReceiptPolicy_inAdditionTo                              */
/*                                                            */
/**************************************************************/

#define TV_MLReceiptPolicy_inAdditionTo	(TM_CTXT|TM_CONS|2)

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

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

   ASN1C_MLReceiptPolicy_inAdditionTo& operator= (ASN1C_MLReceiptPolicy_inAdditionTo& srcData);
   void Append (ASN1T_GeneralNames * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_MLReceiptPolicy_inAdditionTo (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy_inAdditionTo *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MLReceiptPolicy_inAdditionTo (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy_inAdditionTo *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MLReceiptPolicy_inAdditionTo (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy_inAdditionTo* pSrcValue, ASN1T_MLReceiptPolicy_inAdditionTo* pDstValue);

EXTERN void asn1Free_MLReceiptPolicy_inAdditionTo (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy_inAdditionTo* pvalue);

/**************************************************************/
/*                                                            */
/*  MLReceiptPolicy                                           */
/*                                                            */
/**************************************************************/

/* Choice tag constants */

#define T_MLReceiptPolicy_none          1
#define T_MLReceiptPolicy_insteadOf     2
#define T_MLReceiptPolicy_inAdditionTo  3

class EXTERN ASN1C_MLReceiptPolicy;

typedef struct EXTERN ASN1T_MLReceiptPolicy : public ASN1TPDU {
   int t;
   union {
      /* t = 1 */
      /* t = 2 */
      ASN1T_MLReceiptPolicy_insteadOf *insteadOf;
      /* t = 3 */
      ASN1T_MLReceiptPolicy_inAdditionTo *inAdditionTo;
   } u;
   ASN1T_MLReceiptPolicy () {}
   ASN1T_MLReceiptPolicy (ASN1C_MLReceiptPolicy& srcData);
   ~ASN1T_MLReceiptPolicy ();
} ASN1T_MLReceiptPolicy;

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

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

EXTERN int asn1E_MLReceiptPolicy (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MLReceiptPolicy (ASN1CTXT* pctxt,
   ASN1T_MLReceiptPolicy *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MLReceiptPolicy (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy* pSrcValue, ASN1T_MLReceiptPolicy* pDstValue);

EXTERN void asn1Free_MLReceiptPolicy (ASN1CTXT *pctxt, ASN1T_MLReceiptPolicy* pvalue);

/**************************************************************/
/*                                                            */
/*  MLData                                                    */
/*                                                            */
/**************************************************************/

class EXTERN ASN1C_MLData;

typedef struct EXTERN ASN1T_MLData : public ASN1TPDU {
   struct {
      unsigned mlReceiptPolicyPresent : 1;
   } m;
   ASN1T_EntityIdentifier mailListIdentifier;
   ASN1GeneralizedTime expansionTime;
   ASN1T_MLReceiptPolicy mlReceiptPolicy;
   ASN1T_MLData ();
   ASN1T_MLData (ASN1C_MLData& srcData);
   ~ASN1T_MLData ();
} ASN1T_MLData;

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

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

EXTERN int asn1E_MLData (ASN1CTXT* pctxt,
   ASN1T_MLData *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MLData (ASN1CTXT* pctxt,
   ASN1T_MLData *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MLData (ASN1CTXT *pctxt, ASN1T_MLData* pSrcValue, ASN1T_MLData* pDstValue);

EXTERN void asn1Free_MLData (ASN1CTXT *pctxt, ASN1T_MLData* pvalue);

/**************************************************************/
/*                                                            */
/*  MLExpansionHistory                                        */
/*                                                            */
/**************************************************************/

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

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

   ASN1C_MLExpansionHistory& operator= (ASN1C_MLExpansionHistory& srcData);
   void Append (ASN1T_MLData * elem) {
      append ((void*)elem);
   }
} ;

EXTERN int asn1E_MLExpansionHistory (ASN1CTXT* pctxt,
   ASN1T_MLExpansionHistory *pvalue, ASN1TagType tagging);

EXTERN int asn1D_MLExpansionHistory (ASN1CTXT* pctxt,
   ASN1T_MLExpansionHistory *pvalue, ASN1TagType tagging, int length);

EXTERN void asn1Copy_MLExpansionHistory (ASN1CTXT *pctxt, ASN1T_MLExpansionHistory* pSrcValue, ASN1T_MLExpansionHistory* pDstValue);

EXTERN void asn1Free_MLExpansionHistory (ASN1CTXT *pctxt, ASN1T_MLExpansionHistory* pvalue);

/* Value definitions */

#define ASN1V_ub_receiptsTo 16
extern EXTERN ASN1OBJID id_aa_receiptRequest;
extern EXTERN ASN1OBJID id_aa_contentIdentifier;
extern EXTERN ASN1OBJID id_ct_receipt;
extern EXTERN ASN1OBJID id_aa_contentHint;
extern EXTERN ASN1OBJID id_aa_msgSigDigest;
extern EXTERN ASN1OBJID id_aa_contentReference;
extern EXTERN ASN1OBJID id_aa_securityLabel;
#define ASN1V_ub_privacy_mark_length 128
#define ASN1V_ub_security_categories 64
extern EXTERN ASN1OBJID id_aa_equivalentLabels;
extern EXTERN ASN1OBJID id_aa_mlExpandHistory;
#define ASN1V_ub_ml_expansion_history 64

}
#endif
