/*
 * Name: ITEXAccessClasses.hh
 *
 *=========================================================================
 * Copyright (c) 1994-1998 Telelogic AB, Sweden.
 * All rights reserved.
 *
 *=========================================================================
 *
 * Description:
 * 
 *  One of the ITEX Access API definition files.
 */

#ifndef ITEXAccessClasses_HH
# define ITEXAccessClasses_HH

#ifndef ITEXACCESS_DUMMY_NODEINFO
# define ITEXACCESS_DUMMY_NODEINFO

class NodeInfo
{
private:
  void* rfm;
};

#endif

/* This is defined in access.hh for backward compatibility  */
#ifndef ITEXACCESS_DEREF
/* This other declaration prevents operator-> to be defined */
#define ITEXACCESS_DEREF( c ) /* no expansion for c */
#endif


#include <stdio.h>		/* For FILE */
#include <time.h>		/* For time_t */

typedef int INT32;
typedef unsigned int UINT32;

typedef short INT16;
typedef unsigned short UINT16;

typedef char INT8;		/* Assumes signed chars */
typedef unsigned char UINT8;

typedef INT32 Key;
typedef UINT16 Counter16;
typedef UINT32 Counter32;


#ifdef __cplusplus           /* Is using a C++ compiler */


#ifndef _XtIntrinsic_h

/*
 * Add an extra level of clash prevention. If a file includes both
 * "Intrinsic.h" and this file, "Intrinsic.h" shall be included first.
 * ( 931125 09:49 janeriks )
 */

typedef int Boolean;

#endif

#endif


class Inode;
class Suite;
class SymbolTable;
class Table;
class Row;
class String;
class ItexSystem;

typedef const char Field;
typedef class PT_StaticNode PT;


class Astring
{
friend int operator==(const char* cs, const Astring& s);
friend int operator!=(const char* cs, const Astring& s);
friend FILE& operator<<(FILE& f, const Astring& s);
friend FILE& operator>>(FILE& strm, Astring& s);

private:
  // Pointer because otherwise access.hh must know the size of
  // the String object
  String* _s;

public:
  Astring();
  Astring(const char* s);
  Astring(const char s);
  // end should point to the char after the last char
  Astring(const char* begin, const char* end);
  Astring(const Astring& orig);

  ~Astring();

  // ========= x-viv ===========
  void change(char c1, char c2);
  // ---------------------------

  //operators
  Astring* operator->();
  const Astring* operator->() const;
  operator const char*() const;
  char& operator[](unsigned i) ;
  char operator[](unsigned i) const ;
  unsigned length() const;
  
  void operator=(const Astring&);
  void operator=(const String&);
  void operator=(const char*);
  void operator=(const char);
  
  int operator==(const Astring& s) const;
  int operator!=(const Astring& s) const;
  int operator==(const char* cs) const;
  int operator!=(const char* cs) const;

  Astring& operator<<(const Astring&);
  Astring& operator<<(const char* cs);
  Astring& operator<<(const long);
  Astring& operator<<(const int);
  Astring& operator<<(const short);
  Astring& operator<<(const unsigned long);
  Astring& operator<<(const unsigned int);
  Astring& operator<<(const unsigned short);
  Astring& operator<<(const char ch);
friend Astring operator<<(const char ch, Astring& as);
};



/* User assignable. */
extern void (*access_error) ( const char* format,  ... );
extern void (*trav_error) ( const char* format,  ... );
extern void (*pre_post_error) ( const char* format,  ... );

/* Not user assignable. */
void access_internal_error( const char* format,  ... );


class AccessNode;
class Identifier;


class StaticNode
{
protected:
  NodeInfo _nodeinfo;
public:
  time_t                modified_time() const;
  time_t                analyse_time() const;
  Boolean               is_equal(const StaticNode&) const;

  const AccessNode      find( const Identifier & ) const;
  const AccessNode      find( const char * ) const;
};


class TableNode : public StaticNode
{
protected:
  Table* _tab;


public:
  const Astring table_name() const;
  Boolean is_analysed() const;
  Boolean is_selected();
  Boolean have_selected_below();
  Boolean is_equal(const TableNode&) const;
};





class RowBase
{
protected:
  Row* _row;

};



class RowNode : public TableNode, public RowBase
{
public:
  Boolean is_equal(const RowNode&) const;
};





class ParseTreeNode : public TableNode
{
protected:
  Field* _field;
  PT* _pt;

public:
  Astring content() const;
  Boolean is_equal(const ParseTreeNode&) const;
};





class TerminalNode : public ParseTreeNode, public Astring
{
public:
  int start_pos() const;
  int length() const;
};





class ParseTreeRowNode : public ParseTreeNode, public RowBase
{
};





class ListBase
{
protected:
  int _nr_of_items;

public:
  int nr_of_items() const;
};





class StaticList : public StaticNode, public ListBase
{
};





class TableList : public TableNode, public ListBase
{
};





class RowList : public RowNode, public ListBase
{
protected:
  // 'mutable' attributes:
  Row* _row_cache;
  int _cache_idx;

};





class ParseTreeList : public ParseTreeNode, public ListBase
{
};





class MultipleTypeConstraints;
class TS_ConstRefList;
class InvalidFieldEncodingDefs;
class AEXPLICIT;
class AnyDefinedBy;
class ValueBound;
class Pass;
class CM_Id;
class PCO_List;
class TC_VarDcl;
class RecordRef;
class TTCN_Type;
class SO_StructureAndObjectives;
class R_TYPE;
class ParentSubType;
class VariationRef;
class TS_ProcId;
class Configuration;
class SO_StepIndex;
class Mult;
class BuiltinType;
class CM_ParValues;
class ExpandedId;
class ASN1_TypeDefs;
class ArrayRef;
class TestGroup;
class TS_VarId;
class TS_ProcDefs;
class ASN1_ValueList;
class ASN1_PDU_TypeDefByRefList;
class PCO_Dcls;
class ASP_ParValues;
class EncodingVariations;
class SpecialRealValue;
class ReadTimer;
class ObjectName;
class PartialSpecification;
class TCompIdList;
class Event;
class PDU_FieldValues;
class TTCN_ASP_TypeDef;
class InvalidFieldEncodingId;
class Max;
class Inconclusive;
class PICS_PIXITref;
class ObjIdComponentList;
class DefaultGroupOrDefault;
class Result;
class ASP_ParIdOrMacro;
class PCO_DclList;
class TC_Role;
class StructId;
class MinusINFINITY;
class NullValue;
class TestStepLibrary;
class NumberForm;
class ClassType;
class Label;
class Replacement;
class TTCN_ASP_Constraints;
class SimpleValueList;
class Comment;
class UpperValueBound;
class Assignment;
class TestCases;
class ImportedObject;
class SO_Description;
class SingleValue;
class DefaultExpression;
class ASN1_ConsValue;
class TS_TypeConstraints;
class And;
class NamedValue;
class LocalTreeList;
class EncodingVariationId;
class Expression;
class TTCN_CM_TypeDefs;
class SignedNumber;
class Header;
class CreateAttach;
class TestPurpose;
class RangeTypeLength;
class TS_ProcDef;
class TypeAndAttributes;
class Two;
class SetOfValue;
class DefaultIndex;
class UpperBound;
class PDU;
class ANY;
class DefaultGroupReference;
class Enumeration;
class SelectionType;
class AssignmentList;
class BehaviourLineList;
class PDU_FieldIdAndFullId;
class PDU_EncodingId;
class SetSubType;
class ElementType;
class Timeout;
class ASN1_ASP_TypeDefs;
class SelectExpr;
class SO_DefaultId;
class StructTypeDefs;
class ComponentsOf;
class BitNumber;
class AddOp;
class ValRange;
class ASN1_TypeId;
class ElemId;
class SO_TestMethods;
class Equal;
class WithComponent;
class ClassNumber;
class NamedBitList;
class Repeat;
class SuiteId;
class GreaterOrEqual;
class OPTIONAL;
class PDU_FieldType;
class PCOs_Used;
class SO_DefaultRef;
class ObjectType;
class DefaultIdAndParList;
class CM_ParType;
class ChoiceValue;
class ElemValues;
class ConsId;
class ASN1_TypeRefs;
class SuiteStructure;
class VariationReference;
class TS_ParId;
class NullType;
class Min;
class NamedTypeOrSelection;
class CM_ParId;
class Mantissa;
class R_Value;
class CM_Constraints;
class AliasDefs;
class PCO_TypeDcls;
class SimpleTypeId;
class EncVariationId;
class SO_TestCaseId;
class VideotexString;
class SubType;
class Primary;
class DefaultGroup;
class ASP_ParId;
class TC_VarDclList;
class ATrue;
class VisibleString;
class ContainedSubType;
class BooleanValue;
class TS_VarDcl;
class ASN1_ValueReference;
class UsefulType;
class AliasId;
class ASP_TypeDefs;
class BITSTRING;
class ChoiceType;
class Encoding_TypeList;
class DefaultReference;
class TS_VarType;
class TypeOrPDU;
class GeneralString;
class Cstring;
class ParentType;
class ComponentPosition;
class EventStatement;
class TCompUsed;
class LessOrEqual;
class Less;
class OMIT;
class TestStepIdAndParList;
class Activate;
class ASN1_TypeDef;
class RealType;
class NamedConstraintList;
class SingleTypeConstraint;
class ASN1_CM_Constraint;
class TS_OpDefs;
class Div;
class TTCN_PDU_TypeDef;
class SO_TestStepId;
class Mod;
class ValueAttributes;
class LowerBound;
class PicoSeconds;
class FormalParType;
class ASN1_ASP_TypeDef;
class TimerDcls;
class SelectExprId;
class SO_SuiteId;
class SequenceSubType;
class Attach;
class TCompConfigDcls;
class SO_TestGroupRef;
class Minus;
class Num_CPs;
class SimpleTypeDef;
class ImportedObjectList;
class PrintableString;
class TaggedType;
class TestStepAttachment;
class NONE;
class OCTETSTRING;
class ObjIdComponent;
class AnyType;
class InvalidFieldEncodingDefinition;
class AnyOrOmit;
class TIMER;
class NamedType;
class ComponentIdentifier;
class TS_ConstValue;
class TS_OpDescription;
class TS_TypeDefs;
class ObjectIdentifierType;
class AlternativeTypeList;
class UnaryExpression;
class TestStepRef;
class StartTimer;
class ImplicitSend;
class PDU_FieldDcls;
class StructIdAndFullId;
class EncodingVariation;
class INFINITY;
class DefinedValue;
class CM_ParDcls;
class SourceName;
class ASN1_TypeRef;
class ASN1_TypeAndLocalTypes;
class TestGroupOrTestCaseList;
class MacroSymbol;
class ASN1_LocalTypes;
class ASN1_CM_TypeDefs;
class ASP_IdAndFullId;
class NumOf_PCOs;
class SO_PICSRef;
class DetailedComment;
class Greater;
class UTCTime;
class TCompConfigId;
class SO_PIXITRef;
class SimpleValue;
class SelectExprDefs;
class EncodingDefs;
class TS_ProcResult;
class TreeHeader;
class TestGroupOrTestCase;
class PCO_Id;
class TS_ConstId;
class IntegerRange;
class CompactTestCaseList;
class ASN1_ModuleId;
class ElemIdAndFullId;
class INTEGER;
class Line;
class TTCN_PDU_Constraints;
class PCO_TypeDcl;
class TS_ConstRefs;
class SingleLength;
class UpperTypeBound;
class LowerTypeBound;
class ComponentNumber;
class DefaultRef;
class ASN1_PDU_Constraint;
class TTCN_ASP_TypeDefs;
class PCO_Dcl;
class APPLICATION;
class FormalParList;
class SelectionValue;
class SequenceOfValue;
class CreateTComp;
class ASP_ParDcl;
class Duration;
class TCompConfigDcl;
class TS_VarDcls;
class OctetStringType;
class ASN1_PDU_TypeDefByRef;
class TS_OpResult;
class InvalidFieldEncodingCall;
class ASP_Constraints;
class EncRuleId;
class InvalidFieldEncodingDef;
class Imports;
class TeletexString;
class Create;
class TestCaseId;
class ASN1_ASP_TypeDefByRefList;
class TCompId;
class PTC;
class PRESENT;
class DefaultValue;
class Exponent;
class ValueRange;
class IdOrNum;
class DeclarationsPart;
class ReferenceType;
class EncodingVariationSet;
class Plus;
class TestStepGroupReference;
class InnerTypeConstraints;
class Omit;
class ConstraintExpression;
class ConsRef;
class CompactTestGroup;
class EncodingDefList;
class TS_ParDcl;
class AnyValue;
class DefinedType;
class TTCN_PDU_Constraint;
class TCompConfigInfoList;
class UT;
class PRIVATE_;
class Tag;
class MultExpression;
class UpperRangeBound;
class SO_DefIndexList;
class EncodingReference;
class BitRef;
class UnaryOp;
class ASP_ParIdAndFullId;
class TimerId;
class TimerDcl;
class P_Role;
class TS_ParType;
class FullIdentifier;
class EncVariationIdAndParList;
class ObjectDescriptor;
class T61String;
class ObjectIdentifierValue;
class LowerValueBound;
class PCO_TypeId;
class TestCaseIndex;
class Constraint;
class SizeConstraint;
class ASN1_ASP_Constraint;
class ASP_Id;
class SimpleTypeDefinition;
class IntegerType;
class ArrayRefOrComp;
class CM_TypeDefs;
class NameAndNumberForm;
class SetOfType;
class Factor;
class TestStepId;
class BehaviourLine;
class Children;
class Objective;
class ValueList;
class CP_DclList;
class SuiteOverviewPart;
class ANYValue;
class MultOp;
class ASN1_PDU_TypeDef;
class VariationDefault;
class IF_PRESENT;
class ASN1_ASP_Constraints;
class CM_ParIdOrMacro;
class Or;
class DefaultCase;
class TestStepGroup;
class StructTypeConstraints;
class CP_Id;
class ASN1_TypeRefList;
class StructTypeDef;
class TestGroupReference;
class Base;
class NameForm;
class TTCN_ASP_Constraint;
class FormalParIdList;
class NamedNumberList;
class PDU_FieldDcl;
class EncodingRuleId;
class ElemDcl;
class LocalTree;
class ReferenceList;
class TimeUnit;
class NotEqual;
class NamedConstraint;
class NamedNumber;
class PDU_FieldIdOrMacro;
class SimpleTypeDefs;
class SetValue;
class CM_ParIdAndFullId;
class PDU_FieldId;
class TC_VarId;
class Hstring;
class LowerEndValue;
class Declarations;
class TestStepIndex;
class TypeAndLengthAttribute;
class NanoSeconds;
class NamedTypeAttribute;
class Expansion;
class ComponentReferenceList;
class RootTree;
class Description;
class NumOf_CPs;
class SO_StepIndexList;
class ElemType;
class R;
class Minutes;
class IdentifierList;
class TypeReference;
class ActualCrefParList;
class SelExprId;
class ASN1_TypeConstraint;
class DerivationPath;
class TCompDclList;
class TS_ProcIdAndParList;
class SequenceType;
class ASP_ParType;
class PDU_FieldEncoding;
class INCONC;
class UNIVERSAL;
class DefaultRefList;
class ASP_ParValue;
class TC_VarValue;
class TC_VarType;
class EncodingDefinition;
class ASN1_TypeReference;
class Not;
class Ten;
class NumericRealValue;
class TypeAssignmentList;
class DynamicPart;
class AliasDefList;
class CP_List;
class CPs_Used;
class OmitReference;
class TTCN_CM_TypeDef;
class TS_ConstDclList;
class LengthRestriction;
class TS_ParDcls;
class TestStepGroupId;
class CP_Dcl;
class TS_VarDclList;
class RealValue;
class TCompDcls;
class DeclarationValue;
class SelectionExpression;
class PredefinedType;
class BooleanType;
class Send;
class ASN1_CM_TypeDef;
class ConstraintValueAndAttributesOrReplace;
class InvalidFieldEncodingIdAndParList;
class ConstraintValueAndAttributes;
class Qualifier;
class PDU_IdAndFullId;
class CP_Dcls;
class SelectExprDef;
class CharacterString;
class ISO646String;
class TypeAssignment;
class ParenExpression;
class DefaultId;
class TestStep;
class CreateList;
class ConstraintsPart;
class ASN1_PDU_TypeDefs;
class NumericString;
class BitIdentifier;
class MatchingSymbol;
class TestGroupRef;
class TimerDclList;
class TS_ParDclList;
class FormalParAndType;
class ReplacementList;
class Minus_INFINITY;
class GraphicString;
class ElementTypeList;
class AddExpression;
class RETURN_;
class LT;
class Identifier;
class PresenceConstraint;
class ComponentReference;
class SingleValueLength;
class TestGroupId;
class GoTo;
class TS_OpId;
class ASuite;
class FAIL;
class Plus_INFINITY;
class SimpleExpression;
class ConsValue;
class TS_ConstDcl;
class SO_StandardsRef;
class EncVariationCall;
class AFalse;
class PreliminaryFAIL;
class OpCall;
class SuperSet;
class LowerRangeBound;
class TimerOp;
class ElemValue;
class SourceRef;
class UpperEndValue;
class SubTypeSpec;
class Term;
class PDU_Constraints;
class PCO_Role;
class ElementValueList;
class SequenceValue;
class SequenceOfType;
class EncodingDefault;
class TestStepGroupOrTestStep;
class WithComponents;
class BehaviourDescription;
class CompactTestCase;
class CM_ParValue;
class TTCN_CM_Constraint;
class PDU_TypeDefs;
class TCompDcl;
class TS_ConstType;
class ElemDcls;
class LengthAttribute;
class Permutation;
class DefaultsLibrary;
class DerivPath;
class ImportPart;
class PASS;
class MTC;
class SubtypeValueSet;
class EnumeratedType;
class DefaultGroupOrDefaultList;
class Otherwise;
class LabelId;
class TTCN_CM_Constraints;
class ASN1_ASP_TypeDefsByRef;
class ASP_ParDcls;
class Num_PCOs;
class PreliminaryINCONC;
class PreliminaryPASS;
class ABSENT;
class Done;
class TC_VarDcls;
class TS_VarValue;
class TS_ProcDescription;
class EncodingDefinitions;
class SingleTypeLength;
class IA5String;
class Ostring;
class RangeValueLength;
class Verdict;
class ASN1_PDU_TypeDefsByRef;
class PDU_Id;
class ComplexDefinitions;
class SelectExprDefList;
class ASN1_TypeDefinition;
class SubSet;
class Complement;
class VerdictId;
class DefaultsRef;
class Bstring;
class TagAttributes;
class ActualParList;
class ValueLength;
class TestStepGroupOrTestStepList;
class Cref;
class TimerOps;
class TestCase;
class ASN1_TypeConstraints;
class CM_ParDcl;
class ASN1_Type;
class TimerValue;
class PDU_FieldValue;
class TS_ConstRef;
class EXTERNAL;
class Indentation;
class TypeConstraints;
class LiteralValue;
class StatementLine;
class SO_TestStepRef;
class HEXSTRING;
class NamedTypeAndAttributes;
class ConstraintReference;
class ASN1_PDU_Constraints;
class ConsIdAndParList;
class SO_Objective;
class ParamAndSelection;
class Receive;
class ASN1_CM_Constraints;
class PCO_Type;
class TComp_Role;
class Definitions;
class Seconds;
class ValueConstraint;
class DataObjectReference;
class AliasDef;
class AIMPLICIT;
class BitStringValue;
class Value;
class RelOp;
class RelExpression;
class LineNumber;
class Number;
class TypeAndRestriction;
class TS_OpIdAndParList;
class LowerEndpoint;
class ASN1_Value;
class CancelTimer;
class ImportDeclarations;
class BOOLEAN;
class Replace;
class TCompConfigInfo;
class SO_CaseIndex;
class TS_OpDef;
class ConstraintValue;
class SO_StructureAndObjective;
class PDU_FieldEncodingCall;
class FullSpecification;
class UpperEndpoint;
class PermittedAlphabet;
class BitStringType;
class TreeReference;
class MicroSeconds;
class Fail;
class StructTypeConstraint;
class ASN1_ASP_TypeDefByRef;
class Restriction;
class EncodingRef;
class SO_DefIndex;
class Construct;
class Unit;
class TS_ConstDcls;
class MilliSeconds;
class CP;
class TTCN_PDU_TypeDefs;
class PCO_TypeDclList;
class EncodingVariationList;
class INCLUSIVE;
class SetType;
class SO_SelExprId;
class Bound;
class GeneralizedTime;
class DefaultGroupId;
class RangeLength;
class SimpleTypeDefList;
class SO_CaseIndexList;


/* The enum of all possible nodes/classes in Access. */

class Choices
{

public:
  enum Choice {
    c_invalid_choice = 1,
    c_MultipleTypeConstraints = 2,
    c_TS_ConstRefList = 3,
    c_InvalidFieldEncodingDefs = 4,
    c_AEXPLICIT = 5,
    c_AnyDefinedBy = 6,
    c_ValueBound = 7,
    c_Pass = 8,
    c_CM_Id = 9,
    c_PCO_List = 10,
    c_TC_VarDcl = 11,
    c_RecordRef = 12,
    c_TTCN_Type = 13,
    c_SO_StructureAndObjectives = 14,
    c_R_TYPE = 15,
    c_ParentSubType = 16,
    c_VariationRef = 17,
    c_TS_ProcId = 18,
    c_Configuration = 19,
    c_SO_StepIndex = 20,
    c_Mult = 21,
    c_BuiltinType = 22,
    c_CM_ParValues = 23,
    c_ExpandedId = 24,
    c_ASN1_TypeDefs = 25,
    c_ArrayRef = 26,
    c_TestGroup = 27,
    c_TS_VarId = 28,
    c_TS_ProcDefs = 29,
    c_ASN1_ValueList = 30,
    c_ASN1_PDU_TypeDefByRefList = 31,
    c_PCO_Dcls = 32,
    c_ASP_ParValues = 33,
    c_EncodingVariations = 34,
    c_SpecialRealValue = 35,
    c_ReadTimer = 36,
    c_ObjectName = 37,
    c_PartialSpecification = 38,
    c_TCompIdList = 39,
    c_Event = 40,
    c_PDU_FieldValues = 41,
    c_TTCN_ASP_TypeDef = 42,
    c_InvalidFieldEncodingId = 43,
    c_Max = 44,
    c_Inconclusive = 45,
    c_PICS_PIXITref = 46,
    c_ObjIdComponentList = 47,
    c_DefaultGroupOrDefault = 48,
    c_Result = 49,
    c_ASP_ParIdOrMacro = 50,
    c_PCO_DclList = 51,
    c_TC_Role = 52,
    c_StructId = 53,
    c_MinusINFINITY = 54,
    c_NullValue = 55,
    c_TestStepLibrary = 56,
    c_NumberForm = 57,
    c_ClassType = 58,
    c_Label = 59,
    c_Replacement = 60,
    c_TTCN_ASP_Constraints = 61,
    c_SimpleValueList = 62,
    c_Comment = 63,
    c_UpperValueBound = 64,
    c_Assignment = 65,
    c_TestCases = 66,
    c_ImportedObject = 67,
    c_SO_Description = 68,
    c_SingleValue = 69,
    c_DefaultExpression = 70,
    c_ASN1_ConsValue = 71,
    c_TS_TypeConstraints = 72,
    c_And = 73,
    c_NamedValue = 74,
    c_LocalTreeList = 75,
    c_EncodingVariationId = 76,
    c_Expression = 77,
    c_TTCN_CM_TypeDefs = 78,
    c_SignedNumber = 79,
    c_Header = 80,
    c_CreateAttach = 81,
    c_TestPurpose = 82,
    c_RangeTypeLength = 83,
    c_TS_ProcDef = 84,
    c_TypeAndAttributes = 85,
    c_Two = 86,
    c_SetOfValue = 87,
    c_DefaultIndex = 88,
    c_UpperBound = 89,
    c_PDU = 90,
    c_ANY = 91,
    c_DefaultGroupReference = 92,
    c_Enumeration = 93,
    c_SelectionType = 94,
    c_AssignmentList = 95,
    c_BehaviourLineList = 96,
    c_PDU_FieldIdAndFullId = 97,
    c_PDU_EncodingId = 98,
    c_SetSubType = 99,
    c_ElementType = 100,
    c_Timeout = 101,
    c_ASN1_ASP_TypeDefs = 102,
    c_SelectExpr = 103,
    c_SO_DefaultId = 104,
    c_StructTypeDefs = 105,
    c_ComponentsOf = 106,
    c_BitNumber = 107,
    c_AddOp = 108,
    c_ValRange = 109,
    c_ASN1_TypeId = 110,
    c_ElemId = 111,
    c_SO_TestMethods = 112,
    c_Equal = 113,
    c_WithComponent = 114,
    c_ClassNumber = 115,
    c_NamedBitList = 116,
    c_Repeat = 117,
    c_SuiteId = 118,
    c_GreaterOrEqual = 119,
    c_OPTIONAL = 120,
    c_PDU_FieldType = 121,
    c_PCOs_Used = 122,
    c_SO_DefaultRef = 123,
    c_ObjectType = 124,
    c_DefaultIdAndParList = 125,
    c_CM_ParType = 126,
    c_ChoiceValue = 127,
    c_ElemValues = 128,
    c_ConsId = 129,
    c_ASN1_TypeRefs = 130,
    c_SuiteStructure = 131,
    c_VariationReference = 132,
    c_TS_ParId = 133,
    c_NullType = 134,
    c_Min = 135,
    c_NamedTypeOrSelection = 136,
    c_CM_ParId = 137,
    c_Mantissa = 138,
    c_R_Value = 139,
    c_CM_Constraints = 140,
    c_AliasDefs = 141,
    c_PCO_TypeDcls = 142,
    c_SimpleTypeId = 143,
    c_EncVariationId = 144,
    c_SO_TestCaseId = 145,
    c_VideotexString = 146,
    c_SubType = 147,
    c_Primary = 148,
    c_DefaultGroup = 149,
    c_ASP_ParId = 150,
    c_TC_VarDclList = 151,
    c_ATrue = 152,
    c_VisibleString = 153,
    c_ContainedSubType = 154,
    c_BooleanValue = 155,
    c_TS_VarDcl = 156,
    c_ASN1_ValueReference = 157,
    c_UsefulType = 158,
    c_AliasId = 159,
    c_ASP_TypeDefs = 160,
    c_BITSTRING = 161,
    c_ChoiceType = 162,
    c_Encoding_TypeList = 163,
    c_DefaultReference = 164,
    c_TS_VarType = 165,
    c_TypeOrPDU = 166,
    c_GeneralString = 167,
    c_Cstring = 168,
    c_ParentType = 169,
    c_ComponentPosition = 170,
    c_EventStatement = 171,
    c_TCompUsed = 172,
    c_LessOrEqual = 173,
    c_Less = 174,
    c_OMIT = 175,
    c_TestStepIdAndParList = 176,
    c_Activate = 177,
    c_ASN1_TypeDef = 178,
    c_RealType = 179,
    c_NamedConstraintList = 180,
    c_SingleTypeConstraint = 181,
    c_ASN1_CM_Constraint = 182,
    c_TS_OpDefs = 183,
    c_Div = 184,
    c_TTCN_PDU_TypeDef = 185,
    c_SO_TestStepId = 186,
    c_Mod = 187,
    c_ValueAttributes = 188,
    c_LowerBound = 189,
    c_PicoSeconds = 190,
    c_FormalParType = 191,
    c_ASN1_ASP_TypeDef = 192,
    c_TimerDcls = 193,
    c_SelectExprId = 194,
    c_SO_SuiteId = 195,
    c_SequenceSubType = 196,
    c_Attach = 197,
    c_TCompConfigDcls = 198,
    c_SO_TestGroupRef = 199,
    c_Minus = 200,
    c_Num_CPs = 201,
    c_SimpleTypeDef = 202,
    c_ImportedObjectList = 203,
    c_PrintableString = 204,
    c_TaggedType = 205,
    c_TestStepAttachment = 206,
    c_NONE = 207,
    c_OCTETSTRING = 208,
    c_ObjIdComponent = 209,
    c_AnyType = 210,
    c_InvalidFieldEncodingDefinition = 211,
    c_AnyOrOmit = 212,
    c_TIMER = 213,
    c_NamedType = 214,
    c_ComponentIdentifier = 215,
    c_TS_ConstValue = 216,
    c_TS_OpDescription = 217,
    c_TS_TypeDefs = 218,
    c_ObjectIdentifierType = 219,
    c_AlternativeTypeList = 220,
    c_UnaryExpression = 221,
    c_TestStepRef = 222,
    c_StartTimer = 223,
    c_ImplicitSend = 224,
    c_PDU_FieldDcls = 225,
    c_StructIdAndFullId = 226,
    c_EncodingVariation = 227,
    c_INFINITY = 228,
    c_DefinedValue = 229,
    c_CM_ParDcls = 230,
    c_SourceName = 231,
    c_ASN1_TypeRef = 232,
    c_ASN1_TypeAndLocalTypes = 233,
    c_TestGroupOrTestCaseList = 234,
    c_MacroSymbol = 235,
    c_ASN1_LocalTypes = 236,
    c_ASN1_CM_TypeDefs = 237,
    c_ASP_IdAndFullId = 238,
    c_NumOf_PCOs = 239,
    c_SO_PICSRef = 240,
    c_DetailedComment = 241,
    c_Greater = 242,
    c_UTCTime = 243,
    c_TCompConfigId = 244,
    c_SO_PIXITRef = 245,
    c_SimpleValue = 246,
    c_SelectExprDefs = 247,
    c_EncodingDefs = 248,
    c_TS_ProcResult = 249,
    c_TreeHeader = 250,
    c_TestGroupOrTestCase = 251,
    c_PCO_Id = 252,
    c_TS_ConstId = 253,
    c_IntegerRange = 254,
    c_CompactTestCaseList = 255,
    c_ASN1_ModuleId = 256,
    c_ElemIdAndFullId = 257,
    c_INTEGER = 258,
    c_Line = 259,
    c_TTCN_PDU_Constraints = 260,
    c_PCO_TypeDcl = 261,
    c_TS_ConstRefs = 262,
    c_SingleLength = 263,
    c_UpperTypeBound = 264,
    c_LowerTypeBound = 265,
    c_ComponentNumber = 266,
    c_DefaultRef = 267,
    c_ASN1_PDU_Constraint = 268,
    c_TTCN_ASP_TypeDefs = 269,
    c_PCO_Dcl = 270,
    c_APPLICATION = 271,
    c_FormalParList = 272,
    c_SelectionValue = 273,
    c_SequenceOfValue = 274,
    c_CreateTComp = 275,
    c_ASP_ParDcl = 276,
    c_Duration = 277,
    c_TCompConfigDcl = 278,
    c_TS_VarDcls = 279,
    c_OctetStringType = 280,
    c_ASN1_PDU_TypeDefByRef = 281,
    c_TS_OpResult = 282,
    c_InvalidFieldEncodingCall = 283,
    c_ASP_Constraints = 284,
    c_EncRuleId = 285,
    c_InvalidFieldEncodingDef = 286,
    c_Imports = 287,
    c_TeletexString = 288,
    c_Create = 289,
    c_TestCaseId = 290,
    c_ASN1_ASP_TypeDefByRefList = 291,
    c_TCompId = 292,
    c_PTC = 293,
    c_PRESENT = 294,
    c_DefaultValue = 295,
    c_Exponent = 296,
    c_ValueRange = 297,
    c_IdOrNum = 298,
    c_DeclarationsPart = 299,
    c_ReferenceType = 300,
    c_EncodingVariationSet = 301,
    c_Plus = 302,
    c_TestStepGroupReference = 303,
    c_InnerTypeConstraints = 304,
    c_Omit = 305,
    c_ConstraintExpression = 306,
    c_ConsRef = 307,
    c_CompactTestGroup = 308,
    c_EncodingDefList = 309,
    c_TS_ParDcl = 310,
    c_AnyValue = 311,
    c_DefinedType = 312,
    c_TTCN_PDU_Constraint = 313,
    c_TCompConfigInfoList = 314,
    c_UT = 315,
    c_PRIVATE_ = 316,
    c_Tag = 317,
    c_MultExpression = 318,
    c_UpperRangeBound = 319,
    c_SO_DefIndexList = 320,
    c_EncodingReference = 321,
    c_BitRef = 322,
    c_UnaryOp = 323,
    c_ASP_ParIdAndFullId = 324,
    c_TimerId = 325,
    c_TimerDcl = 326,
    c_P_Role = 327,
    c_TS_ParType = 328,
    c_FullIdentifier = 329,
    c_EncVariationIdAndParList = 330,
    c_ObjectDescriptor = 331,
    c_T61String = 332,
    c_ObjectIdentifierValue = 333,
    c_LowerValueBound = 334,
    c_PCO_TypeId = 335,
    c_TestCaseIndex = 336,
    c_Constraint = 337,
    c_SizeConstraint = 338,
    c_ASN1_ASP_Constraint = 339,
    c_ASP_Id = 340,
    c_SimpleTypeDefinition = 341,
    c_IntegerType = 342,
    c_ArrayRefOrComp = 343,
    c_CM_TypeDefs = 344,
    c_NameAndNumberForm = 345,
    c_SetOfType = 346,
    c_Factor = 347,
    c_TestStepId = 348,
    c_BehaviourLine = 349,
    c_Children = 350,
    c_Objective = 351,
    c_ValueList = 352,
    c_CP_DclList = 353,
    c_SuiteOverviewPart = 354,
    c_ANYValue = 355,
    c_MultOp = 356,
    c_ASN1_PDU_TypeDef = 357,
    c_VariationDefault = 358,
    c_IF_PRESENT = 359,
    c_ASN1_ASP_Constraints = 360,
    c_CM_ParIdOrMacro = 361,
    c_Or = 362,
    c_DefaultCase = 363,
    c_TestStepGroup = 364,
    c_StructTypeConstraints = 365,
    c_CP_Id = 366,
    c_ASN1_TypeRefList = 367,
    c_StructTypeDef = 368,
    c_TestGroupReference = 369,
    c_Base = 370,
    c_NameForm = 371,
    c_TTCN_ASP_Constraint = 372,
    c_FormalParIdList = 373,
    c_NamedNumberList = 374,
    c_PDU_FieldDcl = 375,
    c_EncodingRuleId = 376,
    c_ElemDcl = 377,
    c_LocalTree = 378,
    c_ReferenceList = 379,
    c_TimeUnit = 380,
    c_NotEqual = 381,
    c_NamedConstraint = 382,
    c_NamedNumber = 383,
    c_PDU_FieldIdOrMacro = 384,
    c_SimpleTypeDefs = 385,
    c_SetValue = 386,
    c_CM_ParIdAndFullId = 387,
    c_PDU_FieldId = 388,
    c_TC_VarId = 389,
    c_Hstring = 390,
    c_LowerEndValue = 391,
    c_Declarations = 392,
    c_TestStepIndex = 393,
    c_TypeAndLengthAttribute = 394,
    c_NanoSeconds = 395,
    c_NamedTypeAttribute = 396,
    c_Expansion = 397,
    c_ComponentReferenceList = 398,
    c_RootTree = 399,
    c_Description = 400,
    c_NumOf_CPs = 401,
    c_SO_StepIndexList = 402,
    c_ElemType = 403,
    c_R = 404,
    c_Minutes = 405,
    c_IdentifierList = 406,
    c_TypeReference = 407,
    c_ActualCrefParList = 408,
    c_SelExprId = 409,
    c_ASN1_TypeConstraint = 410,
    c_DerivationPath = 411,
    c_TCompDclList = 412,
    c_TS_ProcIdAndParList = 413,
    c_SequenceType = 414,
    c_ASP_ParType = 415,
    c_PDU_FieldEncoding = 416,
    c_INCONC = 417,
    c_UNIVERSAL = 418,
    c_DefaultRefList = 419,
    c_ASP_ParValue = 420,
    c_TC_VarValue = 421,
    c_TC_VarType = 422,
    c_EncodingDefinition = 423,
    c_ASN1_TypeReference = 424,
    c_Not = 425,
    c_Ten = 426,
    c_NumericRealValue = 427,
    c_TypeAssignmentList = 428,
    c_DynamicPart = 429,
    c_AliasDefList = 430,
    c_CP_List = 431,
    c_CPs_Used = 432,
    c_OmitReference = 433,
    c_TTCN_CM_TypeDef = 434,
    c_TS_ConstDclList = 435,
    c_LengthRestriction = 436,
    c_TS_ParDcls = 437,
    c_TestStepGroupId = 438,
    c_CP_Dcl = 439,
    c_TS_VarDclList = 440,
    c_RealValue = 441,
    c_TCompDcls = 442,
    c_DeclarationValue = 443,
    c_SelectionExpression = 444,
    c_PredefinedType = 445,
    c_BooleanType = 446,
    c_Send = 447,
    c_ASN1_CM_TypeDef = 448,
    c_ConstraintValueAndAttributesOrReplace = 449,
    c_InvalidFieldEncodingIdAndParList = 450,
    c_ConstraintValueAndAttributes = 451,
    c_Qualifier = 452,
    c_PDU_IdAndFullId = 453,
    c_CP_Dcls = 454,
    c_SelectExprDef = 455,
    c_CharacterString = 456,
    c_ISO646String = 457,
    c_TypeAssignment = 458,
    c_ParenExpression = 459,
    c_DefaultId = 460,
    c_TestStep = 461,
    c_CreateList = 462,
    c_ConstraintsPart = 463,
    c_ASN1_PDU_TypeDefs = 464,
    c_NumericString = 465,
    c_BitIdentifier = 466,
    c_MatchingSymbol = 467,
    c_TestGroupRef = 468,
    c_TimerDclList = 469,
    c_TS_ParDclList = 470,
    c_FormalParAndType = 471,
    c_ReplacementList = 472,
    c_Minus_INFINITY = 473,
    c_GraphicString = 474,
    c_ElementTypeList = 475,
    c_AddExpression = 476,
    c_RETURN_ = 477,
    c_LT = 478,
    c_Identifier = 479,
    c_PresenceConstraint = 480,
    c_ComponentReference = 481,
    c_SingleValueLength = 482,
    c_TestGroupId = 483,
    c_GoTo = 484,
    c_TS_OpId = 485,
    c_ASuite = 486,
    c_FAIL = 487,
    c_Plus_INFINITY = 488,
    c_SimpleExpression = 489,
    c_ConsValue = 490,
    c_TS_ConstDcl = 491,
    c_SO_StandardsRef = 492,
    c_EncVariationCall = 493,
    c_AFalse = 494,
    c_PreliminaryFAIL = 495,
    c_OpCall = 496,
    c_SuperSet = 497,
    c_LowerRangeBound = 498,
    c_TimerOp = 499,
    c_ElemValue = 500,
    c_SourceRef = 501,
    c_UpperEndValue = 502,
    c_SubTypeSpec = 503,
    c_Term = 504,
    c_PDU_Constraints = 505,
    c_PCO_Role = 506,
    c_ElementValueList = 507,
    c_SequenceValue = 508,
    c_SequenceOfType = 509,
    c_EncodingDefault = 510,
    c_TestStepGroupOrTestStep = 511,
    c_WithComponents = 512,
    c_BehaviourDescription = 513,
    c_CompactTestCase = 514,
    c_CM_ParValue = 515,
    c_TTCN_CM_Constraint = 516,
    c_PDU_TypeDefs = 517,
    c_TCompDcl = 518,
    c_TS_ConstType = 519,
    c_ElemDcls = 520,
    c_LengthAttribute = 521,
    c_Permutation = 522,
    c_DefaultsLibrary = 523,
    c_DerivPath = 524,
    c_ImportPart = 525,
    c_PASS = 526,
    c_MTC = 527,
    c_SubtypeValueSet = 528,
    c_EnumeratedType = 529,
    c_DefaultGroupOrDefaultList = 530,
    c_Otherwise = 531,
    c_LabelId = 532,
    c_TTCN_CM_Constraints = 533,
    c_ASN1_ASP_TypeDefsByRef = 534,
    c_ASP_ParDcls = 535,
    c_Num_PCOs = 536,
    c_PreliminaryINCONC = 537,
    c_PreliminaryPASS = 538,
    c_ABSENT = 539,
    c_Done = 540,
    c_TC_VarDcls = 541,
    c_TS_VarValue = 542,
    c_TS_ProcDescription = 543,
    c_EncodingDefinitions = 544,
    c_SingleTypeLength = 545,
    c_IA5String = 546,
    c_Ostring = 547,
    c_RangeValueLength = 548,
    c_Verdict = 549,
    c_ASN1_PDU_TypeDefsByRef = 550,
    c_PDU_Id = 551,
    c_ComplexDefinitions = 552,
    c_SelectExprDefList = 553,
    c_ASN1_TypeDefinition = 554,
    c_SubSet = 555,
    c_Complement = 556,
    c_VerdictId = 557,
    c_DefaultsRef = 558,
    c_Bstring = 559,
    c_TagAttributes = 560,
    c_ActualParList = 561,
    c_ValueLength = 562,
    c_TestStepGroupOrTestStepList = 563,
    c_Cref = 564,
    c_TimerOps = 565,
    c_TestCase = 566,
    c_ASN1_TypeConstraints = 567,
    c_CM_ParDcl = 568,
    c_ASN1_Type = 569,
    c_TimerValue = 570,
    c_PDU_FieldValue = 571,
    c_TS_ConstRef = 572,
    c_EXTERNAL = 573,
    c_Indentation = 574,
    c_TypeConstraints = 575,
    c_LiteralValue = 576,
    c_StatementLine = 577,
    c_SO_TestStepRef = 578,
    c_HEXSTRING = 579,
    c_NamedTypeAndAttributes = 580,
    c_ConstraintReference = 581,
    c_ASN1_PDU_Constraints = 582,
    c_ConsIdAndParList = 583,
    c_SO_Objective = 584,
    c_ParamAndSelection = 585,
    c_Receive = 586,
    c_ASN1_CM_Constraints = 587,
    c_PCO_Type = 588,
    c_TComp_Role = 589,
    c_Definitions = 590,
    c_Seconds = 591,
    c_ValueConstraint = 592,
    c_DataObjectReference = 593,
    c_AliasDef = 594,
    c_AIMPLICIT = 595,
    c_BitStringValue = 596,
    c_Value = 597,
    c_RelOp = 598,
    c_RelExpression = 599,
    c_LineNumber = 600,
    c_Number = 601,
    c_TypeAndRestriction = 602,
    c_TS_OpIdAndParList = 603,
    c_LowerEndpoint = 604,
    c_ASN1_Value = 605,
    c_CancelTimer = 606,
    c_ImportDeclarations = 607,
    c_BOOLEAN = 608,
    c_Replace = 609,
    c_TCompConfigInfo = 610,
    c_SO_CaseIndex = 611,
    c_TS_OpDef = 612,
    c_ConstraintValue = 613,
    c_SO_StructureAndObjective = 614,
    c_PDU_FieldEncodingCall = 615,
    c_FullSpecification = 616,
    c_UpperEndpoint = 617,
    c_PermittedAlphabet = 618,
    c_BitStringType = 619,
    c_TreeReference = 620,
    c_MicroSeconds = 621,
    c_Fail = 622,
    c_StructTypeConstraint = 623,
    c_ASN1_ASP_TypeDefByRef = 624,
    c_Restriction = 625,
    c_EncodingRef = 626,
    c_SO_DefIndex = 627,
    c_Construct = 628,
    c_Unit = 629,
    c_TS_ConstDcls = 630,
    c_MilliSeconds = 631,
    c_CP = 632,
    c_TTCN_PDU_TypeDefs = 633,
    c_PCO_TypeDclList = 634,
    c_EncodingVariationList = 635,
    c_INCLUSIVE = 636,
    c_SetType = 637,
    c_SO_SelExprId = 638,
    c_Bound = 639,
    c_GeneralizedTime = 640,
    c_DefaultGroupId = 641,
    c_RangeLength = 642,
    c_SimpleTypeDefList = 643,
    c_SO_CaseIndexList = 644,
    c_Timer = 645,
    c_PCO = 646,
    c_Elem = 647,
    c_BitString_NamedNumber = 648,
    c_EncodingVar = 649,
    c_CM_Par = 650,
    c_TS_Par = 651,
    c_TS_Op = 652,
    c_TTCN_PDU_Cons = 653,
    c_TTCN_CM = 654,
    c_TTCN_ASP_Cons = 655,
    c_TComp = 656,
    c_ASN1_NamedType = 657,
    c_ASN1_ASP = 658,
    c_Unknown = 659,
    c_ASN1_CM_Cons = 660,
    c_StructCons = 661,
    c_ASN1_CM = 662,
    c_TTCN_PDU = 663,
    c_TTCN_ASP = 664,
    c_TS_Var = 665,
    c_TCompConfig = 666,
    c_PDU_Field = 667,
    c_PredefinedOp = 668,
    c_Enumeration_NamedNumber = 669,
    c_ASP_Par = 670,
    c_ASN1_PDU = 671,
    c_Suite = 672,
    c_ASN1_Cons = 673,
    c_TTCN_CM_Cons = 674,
    c_EncodingRule = 675,
    c_Alias = 676,
    c_ASN1_NameForm = 677,
    c_TS_Const = 678,
    c_TC_Var = 679,
    c_StructType = 680,
    c_Integer_NamedNumber = 681,
    c_ASN1_LocalType = 682,
    c_SimpleType = 683,
    c_FormalParam = 684,
    c_ASN1_PDU_Cons = 685,
    c_ASN1_ASP_Cons = 686,
    c_last_choice = 687
  };

  static const char* to_char(Choices::Choice o);
};


class MultipleTypeConstraints  : public ParseTreeNode
{

public:
  MultipleTypeConstraints( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MultipleTypeConstraints(const MultipleTypeConstraints& orig);
  ~MultipleTypeConstraints();
  void operator=(const MultipleTypeConstraints& orig);
  ITEXACCESS_DEREF(MultipleTypeConstraints)

  FullSpecification fullSpecification() const;
  PartialSpecification partialSpecification() const;
  Choices::Choice choice() const;
};


class TS_ConstRefList  : public StaticList
{

public:
  TS_ConstRefList( NodeInfo nodeinfo);
  TS_ConstRefList(const TS_ConstRefList& orig);
  ~TS_ConstRefList();
  void operator=(const TS_ConstRefList& orig);
  ITEXACCESS_DEREF(TS_ConstRefList)

  TS_ConstRef ts_ConstRef(int index) const;
  TS_ConstRef operator[](int index) const;
};


class InvalidFieldEncodingDefs  : public StaticList
{

public:
  InvalidFieldEncodingDefs( NodeInfo nodeinfo);
  InvalidFieldEncodingDefs(const InvalidFieldEncodingDefs& orig);
  ~InvalidFieldEncodingDefs();
  void operator=(const InvalidFieldEncodingDefs& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingDefs)

  InvalidFieldEncodingDef invalidFieldEncodingDef(int index) const;
  InvalidFieldEncodingDef operator[](int index) const;
};


class AEXPLICIT  : public TerminalNode
{

public:
  AEXPLICIT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AEXPLICIT(const AEXPLICIT& orig);
  ~AEXPLICIT();
  void operator=(const AEXPLICIT& orig);
  ITEXACCESS_DEREF(AEXPLICIT)

};


class AnyDefinedBy  : public ParseTreeNode
{

public:
  AnyDefinedBy( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AnyDefinedBy(const AnyDefinedBy& orig);
  ~AnyDefinedBy();
  void operator=(const AnyDefinedBy& orig);
  ITEXACCESS_DEREF(AnyDefinedBy)

  Identifier identifier() const;
};


class ValueBound  : public ParseTreeNode
{

public:
  ValueBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueBound(const ValueBound& orig);
  ~ValueBound();
  void operator=(const ValueBound& orig);
  ITEXACCESS_DEREF(ValueBound)

  Number number() const;
  Identifier identifier() const;
  Choices::Choice choice() const;
};


class Pass  : public ParseTreeNode
{

public:
  Pass( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Pass(const Pass& orig);
  ~Pass();
  void operator=(const Pass& orig);
  ITEXACCESS_DEREF(Pass)

  PASS pass() const;
  PreliminaryPASS preliminaryPASS() const;
  Choices::Choice choice() const;
};


class CM_Id  : public ParseTreeNode
{

public:
  CM_Id( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CM_Id(const CM_Id& orig);
  ~CM_Id();
  void operator=(const CM_Id& orig);
  ITEXACCESS_DEREF(CM_Id)

  Identifier cm_Identifier() const;
};


class PCO_List  : public ParseTreeList
{

public:
  PCO_List( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCO_List(const PCO_List& orig);
  ~PCO_List();
  void operator=(const PCO_List& orig);
  ITEXACCESS_DEREF(PCO_List)

  Identifier pco_Identifier(int index) const;
  Identifier operator[](int index) const;
};


class TC_VarDcl  : public TableNode
{

public:
  TC_VarDcl( NodeInfo nodeinfo);
  TC_VarDcl(const TC_VarDcl& orig);
  ~TC_VarDcl();
  void operator=(const TC_VarDcl& orig);
  ITEXACCESS_DEREF(TC_VarDcl)

  TC_VarId tc_VarId() const;
  TC_VarType tc_VarType() const;
  TC_VarValue tc_VarValue() const;
  Comment comment() const;

  Boolean is_present_tc_VarId() const;
  Boolean is_present_tc_VarType() const;
  Boolean is_present_tc_VarValue() const;
  Boolean is_present_comment() const;
};


class RecordRef  : public ParseTreeNode
{

public:
  RecordRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RecordRef(const RecordRef& orig);
  ~RecordRef();
  void operator=(const RecordRef& orig);
  ITEXACCESS_DEREF(RecordRef)

  ComponentIdentifier componentIdentifier() const;
};


class TTCN_Type  : public ParseTreeNode
{

public:
  TTCN_Type( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TTCN_Type(const TTCN_Type& orig);
  ~TTCN_Type();
  void operator=(const TTCN_Type& orig);
  ITEXACCESS_DEREF(TTCN_Type)

  PredefinedType predefinedType() const;
  ReferenceType referenceType() const;
  Choices::Choice choice() const;
};


class SO_StructureAndObjectives  : public RowList
{

public:
  SO_StructureAndObjectives( NodeInfo nodeinfo,  Table* tab);
  SO_StructureAndObjectives(const SO_StructureAndObjectives& orig);
  ~SO_StructureAndObjectives();
  void operator=(const SO_StructureAndObjectives& orig);
  ITEXACCESS_DEREF(SO_StructureAndObjectives)

  SO_StructureAndObjective SO_structureAndObjective(int index) const;
  SO_StructureAndObjective operator[](int index) const;
};


class R_TYPE  : public TerminalNode
{

public:
  R_TYPE( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  R_TYPE(const R_TYPE& orig);
  ~R_TYPE();
  void operator=(const R_TYPE& orig);
  ITEXACCESS_DEREF(R_TYPE)

};


class ParentSubType  : public ParseTreeNode
{

public:
  ParentSubType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ParentSubType(const ParentSubType& orig);
  ~ParentSubType();
  void operator=(const ParentSubType& orig);
  ITEXACCESS_DEREF(ParentSubType)

  ParentType parentType() const;
  SubTypeSpec subTypeSpec() const;
};


class VariationRef  : public ParseTreeNode
{

public:
  VariationRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VariationRef(const VariationRef& orig);
  ~VariationRef();
  void operator=(const VariationRef& orig);
  ITEXACCESS_DEREF(VariationRef)

  VariationReference variationReference() const;
};


class TS_ProcId  : public ParseTreeNode
{

public:
  TS_ProcId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ProcId(const TS_ProcId& orig);
  ~TS_ProcId();
  void operator=(const TS_ProcId& orig);
  ITEXACCESS_DEREF(TS_ProcId)

  TS_ProcIdAndParList ts_ProcIdAndParList() const;
};


class Configuration  : public ParseTreeNode
{

public:
  Configuration( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Configuration(const Configuration& orig);
  ~Configuration();
  void operator=(const Configuration& orig);
  ITEXACCESS_DEREF(Configuration)

  Identifier tcompConfigIdentifier() const;
};


class SO_StepIndex  : public RowNode
{

public:
  SO_StepIndex( NodeInfo nodeinfo,  Table* tab,  Row* row);
  SO_StepIndex(const SO_StepIndex& orig);
  ~SO_StepIndex();
  void operator=(const SO_StepIndex& orig);
  ITEXACCESS_DEREF(SO_StepIndex)

  SO_TestStepRef SO_testStepRef() const;
  SO_TestStepId SO_testStepId() const;
  SO_Description SO_description() const;

  Boolean is_present_SO_testStepRef() const;
  Boolean is_present_SO_testStepId() const;
  Boolean is_present_SO_description() const;
};


class Mult  : public TerminalNode
{

public:
  Mult( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Mult(const Mult& orig);
  ~Mult();
  void operator=(const Mult& orig);
  ITEXACCESS_DEREF(Mult)

};


class BuiltinType  : public ParseTreeNode
{

public:
  BuiltinType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BuiltinType(const BuiltinType& orig);
  ~BuiltinType();
  void operator=(const BuiltinType& orig);
  ITEXACCESS_DEREF(BuiltinType)

  BooleanType booleanType() const;
  IntegerType integerType() const;
  BitStringType bitStringType() const;
  OctetStringType octetStringType() const;
  NullType nullType() const;
  SequenceType sequenceType() const;
  SequenceOfType sequenceOfType() const;
  SetType setType() const;
  SetOfType setOfType() const;
  ChoiceType choiceType() const;
  SelectionType selectionType() const;
  TaggedType taggedType() const;
  AnyType anyType() const;
  ObjectIdentifierType objectIdentifierType() const;
  CharacterString characterString() const;
  UsefulType usefulType() const;
  EnumeratedType enumeratedType() const;
  RealType realType() const;
  Choices::Choice choice() const;
};


class CM_ParValues  : public RowList
{

public:
  CM_ParValues( NodeInfo nodeinfo,  Table* tab);
  CM_ParValues(const CM_ParValues& orig);
  ~CM_ParValues();
  void operator=(const CM_ParValues& orig);
  ITEXACCESS_DEREF(CM_ParValues)

  CM_ParValue cm_ParValue(int index) const;
  CM_ParValue operator[](int index) const;
};


class ExpandedId  : public ParseTreeNode
{

public:
  ExpandedId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ExpandedId(const ExpandedId& orig);
  ~ExpandedId();
  void operator=(const ExpandedId& orig);
  ITEXACCESS_DEREF(ExpandedId)

  Expansion expansion() const;
};


class ASN1_TypeDefs  : public StaticList
{

public:
  ASN1_TypeDefs( NodeInfo nodeinfo);
  ASN1_TypeDefs(const ASN1_TypeDefs& orig);
  ~ASN1_TypeDefs();
  void operator=(const ASN1_TypeDefs& orig);
  ITEXACCESS_DEREF(ASN1_TypeDefs)

  ASN1_TypeDef asn1_TypeDef(int index) const;
  ASN1_TypeDef operator[](int index) const;
};


class ArrayRef  : public ParseTreeNode
{

public:
  ArrayRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ArrayRef(const ArrayRef& orig);
  ~ArrayRef();
  void operator=(const ArrayRef& orig);
  ITEXACCESS_DEREF(ArrayRef)

  ComponentNumber componentNumber() const;
};


class TestGroup  : public TableNode
{

public:
  TestGroup( NodeInfo nodeinfo);
  TestGroup(const TestGroup& orig);
  ~TestGroup();
  void operator=(const TestGroup& orig);
  ITEXACCESS_DEREF(TestGroup)

  TestGroupId testGroupId() const;
  SelExprId selExprId() const;
  Objective objective() const;
  TestGroupOrTestCaseList testGroupOrTestCaseList() const;

  Boolean is_present_testGroupId() const;
  Boolean is_present_selExprId() const;
  Boolean is_present_objective() const;
};


class TS_VarId  : public ParseTreeNode
{

public:
  TS_VarId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_VarId(const TS_VarId& orig);
  ~TS_VarId();
  void operator=(const TS_VarId& orig);
  ITEXACCESS_DEREF(TS_VarId)

  Identifier ts_VarIdentifier() const;
};


class TS_ProcDefs  : public StaticList
{

public:
  TS_ProcDefs( NodeInfo nodeinfo);
  TS_ProcDefs(const TS_ProcDefs& orig);
  ~TS_ProcDefs();
  void operator=(const TS_ProcDefs& orig);
  ITEXACCESS_DEREF(TS_ProcDefs)

  TS_ProcDef ts_ProcDef(int index) const;
  TS_ProcDef operator[](int index) const;
};


class ASN1_ValueList  : public ParseTreeList
{

public:
  ASN1_ValueList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_ValueList(const ASN1_ValueList& orig);
  ~ASN1_ValueList();
  void operator=(const ASN1_ValueList& orig);
  ITEXACCESS_DEREF(ASN1_ValueList)

  ConstraintValueAndAttributes constraintValueAndAttributes(int index) const;
  ConstraintValueAndAttributes operator[](int index) const;
};


class ASN1_PDU_TypeDefByRefList  : public StaticList
{

public:
  ASN1_PDU_TypeDefByRefList( NodeInfo nodeinfo);
  ASN1_PDU_TypeDefByRefList(const ASN1_PDU_TypeDefByRefList& orig);
  ~ASN1_PDU_TypeDefByRefList();
  void operator=(const ASN1_PDU_TypeDefByRefList& orig);
  ITEXACCESS_DEREF(ASN1_PDU_TypeDefByRefList)

  ASN1_PDU_TypeDefByRef asn1_PDU_TypeDefByRef(int index) const;
  ASN1_PDU_TypeDefByRef operator[](int index) const;
};


class PCO_Dcls  : public TableNode
{

public:
  PCO_Dcls( NodeInfo nodeinfo);
  PCO_Dcls(const PCO_Dcls& orig);
  ~PCO_Dcls();
  void operator=(const PCO_Dcls& orig);
  ITEXACCESS_DEREF(PCO_Dcls)

  PCO_DclList pco_DclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class ASP_ParValues  : public RowList
{

public:
  ASP_ParValues( NodeInfo nodeinfo,  Table* tab);
  ASP_ParValues(const ASP_ParValues& orig);
  ~ASP_ParValues();
  void operator=(const ASP_ParValues& orig);
  ITEXACCESS_DEREF(ASP_ParValues)

  ASP_ParValue asp_ParValue(int index) const;
  ASP_ParValue operator[](int index) const;
};


class EncodingVariations  : public StaticList
{

public:
  EncodingVariations( NodeInfo nodeinfo);
  EncodingVariations(const EncodingVariations& orig);
  ~EncodingVariations();
  void operator=(const EncodingVariations& orig);
  ITEXACCESS_DEREF(EncodingVariations)

  EncodingVariationSet encodingVariationSet(int index) const;
  EncodingVariationSet operator[](int index) const;
};


class SpecialRealValue  : public ParseTreeNode
{

public:
  SpecialRealValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SpecialRealValue(const SpecialRealValue& orig);
  ~SpecialRealValue();
  void operator=(const SpecialRealValue& orig);
  ITEXACCESS_DEREF(SpecialRealValue)

  Plus_INFINITY plus_INFINITY() const;
  Minus_INFINITY minus_INFINITY() const;
  Choices::Choice choice() const;
};


class ReadTimer  : public ParseTreeNode
{

public:
  ReadTimer( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ReadTimer(const ReadTimer& orig);
  ~ReadTimer();
  void operator=(const ReadTimer& orig);
  ITEXACCESS_DEREF(ReadTimer)

  Identifier timerIdentifier() const;
  DataObjectReference dataObjectReference() const;
};


class ObjectName  : public ParseTreeNode
{

public:
  ObjectName( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjectName(const ObjectName& orig);
  ~ObjectName();
  void operator=(const ObjectName& orig);
  ITEXACCESS_DEREF(ObjectName)

  Identifier objectIdentifier() const;
};


class PartialSpecification  : public ParseTreeNode
{

public:
  PartialSpecification( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PartialSpecification(const PartialSpecification& orig);
  ~PartialSpecification();
  void operator=(const PartialSpecification& orig);
  ITEXACCESS_DEREF(PartialSpecification)

  TypeConstraints typeConstraints() const;
};


class TCompIdList  : public ParseTreeList
{

public:
  TCompIdList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TCompIdList(const TCompIdList& orig);
  ~TCompIdList();
  void operator=(const TCompIdList& orig);
  ITEXACCESS_DEREF(TCompIdList)

  Identifier tCompIdentifier(int index) const;
  Identifier operator[](int index) const;
};


class Event  : public ParseTreeNode
{

public:
  Event( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Event(const Event& orig);
  ~Event();
  void operator=(const Event& orig);
  ITEXACCESS_DEREF(Event)

  Send send() const;
  Receive receive() const;
  Otherwise otherwise() const;
  Timeout timeout() const;
  Done done() const;
  Choices::Choice choice() const;
};


class PDU_FieldValues  : public RowList
{

public:
  PDU_FieldValues( NodeInfo nodeinfo,  Table* tab);
  PDU_FieldValues(const PDU_FieldValues& orig);
  ~PDU_FieldValues();
  void operator=(const PDU_FieldValues& orig);
  ITEXACCESS_DEREF(PDU_FieldValues)

  PDU_FieldValue pdu_FieldValue(int index) const;
  PDU_FieldValue operator[](int index) const;
};


class TTCN_ASP_TypeDef  : public TableNode
{

public:
  TTCN_ASP_TypeDef( NodeInfo nodeinfo);
  TTCN_ASP_TypeDef(const TTCN_ASP_TypeDef& orig);
  ~TTCN_ASP_TypeDef();
  void operator=(const TTCN_ASP_TypeDef& orig);
  ITEXACCESS_DEREF(TTCN_ASP_TypeDef)

  ASP_Id asp_Id() const;
  PCO_Type pco_Type() const;
  Comment comment() const;
  ASP_ParDcls asp_ParDcls() const;
  DetailedComment detailedComment() const;

  Boolean is_present_asp_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class InvalidFieldEncodingId  : public ParseTreeNode
{

public:
  InvalidFieldEncodingId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  InvalidFieldEncodingId(const InvalidFieldEncodingId& orig);
  ~InvalidFieldEncodingId();
  void operator=(const InvalidFieldEncodingId& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingId)

  InvalidFieldEncodingIdAndParList invalidFieldEncodingIdAndParList() const;
};


class Max  : public TerminalNode
{

public:
  Max( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Max(const Max& orig);
  ~Max();
  void operator=(const Max& orig);
  ITEXACCESS_DEREF(Max)

};


class Inconclusive  : public ParseTreeNode
{

public:
  Inconclusive( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Inconclusive(const Inconclusive& orig);
  ~Inconclusive();
  void operator=(const Inconclusive& orig);
  ITEXACCESS_DEREF(Inconclusive)

  INCONC inconc() const;
  PreliminaryINCONC preliminaryINCONC() const;
  Choices::Choice choice() const;
};


class PICS_PIXITref  : public TerminalNode
{

public:
  PICS_PIXITref( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PICS_PIXITref(const PICS_PIXITref& orig);
  ~PICS_PIXITref();
  void operator=(const PICS_PIXITref& orig);
  ITEXACCESS_DEREF(PICS_PIXITref)

};


class ObjIdComponentList  : public ParseTreeList
{

public:
  ObjIdComponentList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjIdComponentList(const ObjIdComponentList& orig);
  ~ObjIdComponentList();
  void operator=(const ObjIdComponentList& orig);
  ITEXACCESS_DEREF(ObjIdComponentList)

  ObjIdComponent objIdComponent(int index) const;
  ObjIdComponent operator[](int index) const;
};


class DefaultGroupOrDefault  : public StaticNode
{

public:
  DefaultGroupOrDefault( NodeInfo nodeinfo);
  DefaultGroupOrDefault(const DefaultGroupOrDefault& orig);
  ~DefaultGroupOrDefault();
  void operator=(const DefaultGroupOrDefault& orig);
  ITEXACCESS_DEREF(DefaultGroupOrDefault)

  DefaultGroup defaultGroup() const;
  DefaultCase defaultCase() const;
  Choices::Choice choice() const;
};


class Result  : public ParseTreeNode
{

public:
  Result( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Result(const Result& orig);
  ~Result();
  void operator=(const Result& orig);
  ITEXACCESS_DEREF(Result)

  R r() const;
};


class ASP_ParIdOrMacro  : public ParseTreeNode
{

public:
  ASP_ParIdOrMacro( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_ParIdOrMacro(const ASP_ParIdOrMacro& orig);
  ~ASP_ParIdOrMacro();
  void operator=(const ASP_ParIdOrMacro& orig);
  ITEXACCESS_DEREF(ASP_ParIdOrMacro)

  ASP_ParIdAndFullId asp_ParIdAndFullId() const;
  MacroSymbol macroSymbol() const;
  Choices::Choice choice() const;
};


class PCO_DclList  : public StaticList
{

public:
  PCO_DclList( NodeInfo nodeinfo);
  PCO_DclList(const PCO_DclList& orig);
  ~PCO_DclList();
  void operator=(const PCO_DclList& orig);
  ITEXACCESS_DEREF(PCO_DclList)

  PCO_Dcl pco_Dcl(int index) const;
  PCO_Dcl operator[](int index) const;
};


class TC_Role  : public ParseTreeNode
{

public:
  TC_Role( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TC_Role(const TC_Role& orig);
  ~TC_Role();
  void operator=(const TC_Role& orig);
  ITEXACCESS_DEREF(TC_Role)

  TComp_Role tcomp_Role() const;
};


class StructId  : public ParseTreeNode
{

public:
  StructId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  StructId(const StructId& orig);
  ~StructId();
  void operator=(const StructId& orig);
  ITEXACCESS_DEREF(StructId)

  StructIdAndFullId structIdAndFullId() const;
};


class MinusINFINITY  : public TerminalNode
{

public:
  MinusINFINITY( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MinusINFINITY(const MinusINFINITY& orig);
  ~MinusINFINITY();
  void operator=(const MinusINFINITY& orig);
  ITEXACCESS_DEREF(MinusINFINITY)

};


class NullValue  : public TerminalNode
{

public:
  NullValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NullValue(const NullValue& orig);
  ~NullValue();
  void operator=(const NullValue& orig);
  ITEXACCESS_DEREF(NullValue)

};


class TestStepLibrary  : public StaticNode
{

public:
  TestStepLibrary( NodeInfo nodeinfo);
  TestStepLibrary(const TestStepLibrary& orig);
  ~TestStepLibrary();
  void operator=(const TestStepLibrary& orig);
  ITEXACCESS_DEREF(TestStepLibrary)

  TestStepGroupOrTestStepList testStepGroupOrTestStepList() const;
};


class NumberForm  : public ParseTreeNode
{

public:
  NumberForm( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NumberForm(const NumberForm& orig);
  ~NumberForm();
  void operator=(const NumberForm& orig);
  ITEXACCESS_DEREF(NumberForm)

  Number number() const;
};


class ClassType  : public ParseTreeNode
{

public:
  ClassType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ClassType(const ClassType& orig);
  ~ClassType();
  void operator=(const ClassType& orig);
  ITEXACCESS_DEREF(ClassType)

  UNIVERSAL universal() const;
  APPLICATION application() const;
  PRIVATE_ private_() const;
  Choices::Choice choice() const;
};


class Label  : public ParseTreeNode
{

public:
  Label( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Label(const Label& orig);
  ~Label();
  void operator=(const Label& orig);
  ITEXACCESS_DEREF(Label)

  Identifier identifier() const;
};


class Replacement  : public ParseTreeNode
{

public:
  Replacement( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Replacement(const Replacement& orig);
  ~Replacement();
  void operator=(const Replacement& orig);
  ITEXACCESS_DEREF(Replacement)

  Replace replace() const;
  OmitReference omitReference() const;
  Choices::Choice choice() const;
};


class TTCN_ASP_Constraints  : public StaticList
{

public:
  TTCN_ASP_Constraints( NodeInfo nodeinfo);
  TTCN_ASP_Constraints(const TTCN_ASP_Constraints& orig);
  ~TTCN_ASP_Constraints();
  void operator=(const TTCN_ASP_Constraints& orig);
  ITEXACCESS_DEREF(TTCN_ASP_Constraints)

  TTCN_ASP_Constraint ttcn_ASP_Constraint(int index) const;
  TTCN_ASP_Constraint operator[](int index) const;
};


class SimpleValueList  : public ParseTreeList
{

public:
  SimpleValueList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SimpleValueList(const SimpleValueList& orig);
  ~SimpleValueList();
  void operator=(const SimpleValueList& orig);
  ITEXACCESS_DEREF(SimpleValueList)

  SimpleValue simpleValue(int index) const;
  SimpleValue operator[](int index) const;
};


class Comment  : public TerminalNode
{

public:
  Comment( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Comment(const Comment& orig);
  ~Comment();
  void operator=(const Comment& orig);
  ITEXACCESS_DEREF(Comment)

};


class UpperValueBound  : public ParseTreeNode
{

public:
  UpperValueBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperValueBound(const UpperValueBound& orig);
  ~UpperValueBound();
  void operator=(const UpperValueBound& orig);
  ITEXACCESS_DEREF(UpperValueBound)

  ValueBound valueBound() const;
  INFINITY infinity() const;
  Choices::Choice choice() const;
};


class Assignment  : public ParseTreeNode
{

public:
  Assignment( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Assignment(const Assignment& orig);
  ~Assignment();
  void operator=(const Assignment& orig);
  ITEXACCESS_DEREF(Assignment)

  DataObjectReference dataObjectReference() const;
  Expression expression() const;
};


class TestCases  : public StaticNode
{

public:
  TestCases( NodeInfo nodeinfo);
  TestCases(const TestCases& orig);
  ~TestCases();
  void operator=(const TestCases& orig);
  ITEXACCESS_DEREF(TestCases)

  TestGroupOrTestCaseList testGroupOrTestCaseList() const;
};


class ImportedObject  : public TableNode
{

public:
  ImportedObject( NodeInfo nodeinfo);
  ImportedObject(const ImportedObject& orig);
  ~ImportedObject();
  void operator=(const ImportedObject& orig);
  ITEXACCESS_DEREF(ImportedObject)

  ObjectName objectName() const;
  ObjectType objectType() const;
  SourceName sourceName() const;
  Comment comment() const;
  TestGroupRef testGroupRef() const;
  SelExprId selExprId() const;
  Description description() const;

  Boolean is_present_objectName() const;
  Boolean is_present_objectType() const;
  Boolean is_present_sourceName() const;
  Boolean is_present_comment() const;
  Boolean is_present_testGroupRef() const;
  Boolean is_present_selExprId() const;
  Boolean is_present_description() const;
};


class SO_Description  : public TerminalNode
{

public:
  SO_Description( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_Description(const SO_Description& orig);
  ~SO_Description();
  void operator=(const SO_Description& orig);
  ITEXACCESS_DEREF(SO_Description)

};


class SingleValue  : public ParseTreeNode
{

public:
  SingleValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SingleValue(const SingleValue& orig);
  ~SingleValue();
  void operator=(const SingleValue& orig);
  ITEXACCESS_DEREF(SingleValue)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class DefaultExpression  : public ParseTreeNode
{

public:
  DefaultExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultExpression(const DefaultExpression& orig);
  ~DefaultExpression();
  void operator=(const DefaultExpression& orig);
  ITEXACCESS_DEREF(DefaultExpression)

  Expression expression() const;
};


class ASN1_ConsValue  : public ParseTreeNode
{

public:
  ASN1_ConsValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_ConsValue(const ASN1_ConsValue& orig);
  ~ASN1_ConsValue();
  void operator=(const ASN1_ConsValue& orig);
  ITEXACCESS_DEREF(ASN1_ConsValue)

  ConstraintValueAndAttributesOrReplace constraintValueAndAttributesOrReplace() const;
};


class TS_TypeConstraints  : public StaticNode
{

public:
  TS_TypeConstraints( NodeInfo nodeinfo);
  TS_TypeConstraints(const TS_TypeConstraints& orig);
  ~TS_TypeConstraints();
  void operator=(const TS_TypeConstraints& orig);
  ITEXACCESS_DEREF(TS_TypeConstraints)

  StructTypeConstraints structTypeConstraints() const;
  ASN1_TypeConstraints asn1_TypeConstraints() const;
};


class And  : public TerminalNode
{

public:
  And( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  And(const And& orig);
  ~And();
  void operator=(const And& orig);
  ITEXACCESS_DEREF(And)

};


class NamedValue  : public ParseTreeNode
{

public:
  NamedValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedValue(const NamedValue& orig);
  ~NamedValue();
  void operator=(const NamedValue& orig);
  ITEXACCESS_DEREF(NamedValue)

  Identifier identifier() const;
  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class LocalTreeList  : public RowList
{

public:
  LocalTreeList( NodeInfo nodeinfo,  Table* tab);
  LocalTreeList(const LocalTreeList& orig);
  ~LocalTreeList();
  void operator=(const LocalTreeList& orig);
  ITEXACCESS_DEREF(LocalTreeList)

  LocalTree localTree(int index) const;
  LocalTree operator[](int index) const;
};


class EncodingVariationId  : public ParseTreeNode
{

public:
  EncodingVariationId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncodingVariationId(const EncodingVariationId& orig);
  ~EncodingVariationId();
  void operator=(const EncodingVariationId& orig);
  ITEXACCESS_DEREF(EncodingVariationId)

  EncVariationIdAndParList encVariationIdAndParList() const;
};


class Expression  : public ParseTreeNode
{

public:
  Expression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Expression(const Expression& orig);
  ~Expression();
  void operator=(const Expression& orig);
  ITEXACCESS_DEREF(Expression)

  RelExpression relExpression() const;
  SimpleExpression simpleExpression() const;
  Choices::Choice choice() const;
};


class TTCN_CM_TypeDefs  : public StaticList
{

public:
  TTCN_CM_TypeDefs( NodeInfo nodeinfo);
  TTCN_CM_TypeDefs(const TTCN_CM_TypeDefs& orig);
  ~TTCN_CM_TypeDefs();
  void operator=(const TTCN_CM_TypeDefs& orig);
  ITEXACCESS_DEREF(TTCN_CM_TypeDefs)

  TTCN_CM_TypeDef ttcn_CM_TypeDef(int index) const;
  TTCN_CM_TypeDef operator[](int index) const;
};


class SignedNumber  : public ParseTreeNode
{

public:
  SignedNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SignedNumber(const SignedNumber& orig);
  ~SignedNumber();
  void operator=(const SignedNumber& orig);
  ITEXACCESS_DEREF(SignedNumber)

  Minus minus() const;
  Number number() const;
};


class Header  : public ParseTreeNode
{

public:
  Header( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Header(const Header& orig);
  ~Header();
  void operator=(const Header& orig);
  ITEXACCESS_DEREF(Header)

  TreeHeader treeHeader() const;
};


class CreateAttach  : public ParseTreeNode
{

public:
  CreateAttach( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CreateAttach(const CreateAttach& orig);
  ~CreateAttach();
  void operator=(const CreateAttach& orig);
  ITEXACCESS_DEREF(CreateAttach)

  TreeReference treeReference() const;
  ActualParList actualParList() const;
};


class TestPurpose  : public TerminalNode
{

public:
  TestPurpose( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestPurpose(const TestPurpose& orig);
  ~TestPurpose();
  void operator=(const TestPurpose& orig);
  ITEXACCESS_DEREF(TestPurpose)

};


class RangeTypeLength  : public ParseTreeNode
{

public:
  RangeTypeLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RangeTypeLength(const RangeTypeLength& orig);
  ~RangeTypeLength();
  void operator=(const RangeTypeLength& orig);
  ITEXACCESS_DEREF(RangeTypeLength)

  LowerTypeBound lowerTypeBound() const;
  UpperTypeBound upperTypeBound() const;
};


class TS_ProcDef  : public TableNode
{

public:
  TS_ProcDef( NodeInfo nodeinfo);
  TS_ProcDef(const TS_ProcDef& orig);
  ~TS_ProcDef();
  void operator=(const TS_ProcDef& orig);
  ITEXACCESS_DEREF(TS_ProcDef)

  TS_ProcId ts_ProcId() const;
  TS_ProcResult ts_ProcResult() const;
  Comment comment() const;
  TS_ProcDescription ts_ProcDescription() const;
  DetailedComment detailedComment() const;

  Boolean is_present_ts_ProcId() const;
  Boolean is_present_ts_ProcResult() const;
  Boolean is_present_comment() const;
  Boolean is_present_ts_ProcDescription() const;
  Boolean is_present_detailedComment() const;
};


class TypeAndAttributes  : public ParseTreeNode
{

public:
  TypeAndAttributes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeAndAttributes(const TypeAndAttributes& orig);
  ~TypeAndAttributes();
  void operator=(const TypeAndAttributes& orig);
  ITEXACCESS_DEREF(TypeAndAttributes)

  TypeAndLengthAttribute typeAndLengthAttribute() const;
  PDU pdu() const;
  Choices::Choice choice() const;
};


class Two  : public TerminalNode
{

public:
  Two( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Two(const Two& orig);
  ~Two();
  void operator=(const Two& orig);
  ITEXACCESS_DEREF(Two)

};


class SetOfValue  : public ParseTreeNode
{

public:
  SetOfValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SetOfValue(const SetOfValue& orig);
  ~SetOfValue();
  void operator=(const SetOfValue& orig);
  ITEXACCESS_DEREF(SetOfValue)

  ASN1_ValueList asn1_ValueList() const;
};


class DefaultIndex  : public TableNode
{

public:
  DefaultIndex( NodeInfo nodeinfo);
  DefaultIndex(const DefaultIndex& orig);
  ~DefaultIndex();
  void operator=(const DefaultIndex& orig);
  ITEXACCESS_DEREF(DefaultIndex)

  SO_DefIndexList SO_defIndexList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class UpperBound  : public ParseTreeNode
{

public:
  UpperBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperBound(const UpperBound& orig);
  ~UpperBound();
  void operator=(const UpperBound& orig);
  ITEXACCESS_DEREF(UpperBound)

  Bound bound() const;
  INFINITY infinity() const;
  Choices::Choice choice() const;
};


class PDU  : public TerminalNode
{

public:
  PDU( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU(const PDU& orig);
  ~PDU();
  void operator=(const PDU& orig);
  ITEXACCESS_DEREF(PDU)

};


class ANY  : public TerminalNode
{

public:
  ANY( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ANY(const ANY& orig);
  ~ANY();
  void operator=(const ANY& orig);
  ITEXACCESS_DEREF(ANY)

};


class DefaultGroupReference  : public TerminalNode
{

public:
  DefaultGroupReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultGroupReference(const DefaultGroupReference& orig);
  ~DefaultGroupReference();
  void operator=(const DefaultGroupReference& orig);
  ITEXACCESS_DEREF(DefaultGroupReference)

};


class Enumeration  : public ParseTreeList
{

public:
  Enumeration( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Enumeration(const Enumeration& orig);
  ~Enumeration();
  void operator=(const Enumeration& orig);
  ITEXACCESS_DEREF(Enumeration)

  NamedNumber namedNumber(int index) const;
  NamedNumber operator[](int index) const;
};


class SelectionType  : public ParseTreeNode
{

public:
  SelectionType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelectionType(const SelectionType& orig);
  ~SelectionType();
  void operator=(const SelectionType& orig);
  ITEXACCESS_DEREF(SelectionType)

  Identifier identifier() const;
  ASN1_Type asn1_Type() const;
};


class AssignmentList  : public ParseTreeList
{

public:
  AssignmentList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AssignmentList(const AssignmentList& orig);
  ~AssignmentList();
  void operator=(const AssignmentList& orig);
  ITEXACCESS_DEREF(AssignmentList)

  Assignment assignment(int index) const;
  Assignment operator[](int index) const;
};


class BehaviourLineList  : public RowList
{

public:
  BehaviourLineList( NodeInfo nodeinfo,  Table* tab,  Row* row);
  BehaviourLineList(const BehaviourLineList& orig);
  ~BehaviourLineList();
  void operator=(const BehaviourLineList& orig);
  ITEXACCESS_DEREF(BehaviourLineList)

  BehaviourLine behaviourLine(int index) const;
  BehaviourLine operator[](int index) const;
};


class PDU_FieldIdAndFullId  : public ParseTreeNode
{

public:
  PDU_FieldIdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldIdAndFullId(const PDU_FieldIdAndFullId& orig);
  ~PDU_FieldIdAndFullId();
  void operator=(const PDU_FieldIdAndFullId& orig);
  ITEXACCESS_DEREF(PDU_FieldIdAndFullId)

  Identifier pdu_FieldIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class PDU_EncodingId  : public ParseTreeNode
{

public:
  PDU_EncodingId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_EncodingId(const PDU_EncodingId& orig);
  ~PDU_EncodingId();
  void operator=(const PDU_EncodingId& orig);
  ITEXACCESS_DEREF(PDU_EncodingId)

  Identifier encodingRuleIdentifier() const;
};


class SetSubType  : public ParseTreeNode
{

public:
  SetSubType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SetSubType(const SetSubType& orig);
  ~SetSubType();
  void operator=(const SetSubType& orig);
  ITEXACCESS_DEREF(SetSubType)

  SizeConstraint sizeConstraint() const;
  ASN1_Type asn1_Type() const;
};


class ElementType  : public ParseTreeNode
{

public:
  ElementType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElementType(const ElementType& orig);
  ~ElementType();
  void operator=(const ElementType& orig);
  ITEXACCESS_DEREF(ElementType)

  NamedTypeAndAttributes namedTypeAndAttributes() const;
  ComponentsOf componentsOf() const;
  Choices::Choice choice() const;
};


class Timeout  : public ParseTreeNode
{

public:
  Timeout( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Timeout(const Timeout& orig);
  ~Timeout();
  void operator=(const Timeout& orig);
  ITEXACCESS_DEREF(Timeout)

  Identifier timerIdentifier() const;

  Boolean is_present_timerIdentifier() const;
};


class ASN1_ASP_TypeDefs  : public StaticList
{

public:
  ASN1_ASP_TypeDefs( NodeInfo nodeinfo);
  ASN1_ASP_TypeDefs(const ASN1_ASP_TypeDefs& orig);
  ~ASN1_ASP_TypeDefs();
  void operator=(const ASN1_ASP_TypeDefs& orig);
  ITEXACCESS_DEREF(ASN1_ASP_TypeDefs)

  ASN1_ASP_TypeDef asn1_ASP_TypeDef(int index) const;
  ASN1_ASP_TypeDef operator[](int index) const;
};


class SelectExpr  : public ParseTreeNode
{

public:
  SelectExpr( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelectExpr(const SelectExpr& orig);
  ~SelectExpr();
  void operator=(const SelectExpr& orig);
  ITEXACCESS_DEREF(SelectExpr)

  SelectionExpression selectionExpression() const;
};


class SO_DefaultId  : public TerminalNode
{

public:
  SO_DefaultId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_DefaultId(const SO_DefaultId& orig);
  ~SO_DefaultId();
  void operator=(const SO_DefaultId& orig);
  ITEXACCESS_DEREF(SO_DefaultId)

};


class StructTypeDefs  : public StaticList
{

public:
  StructTypeDefs( NodeInfo nodeinfo);
  StructTypeDefs(const StructTypeDefs& orig);
  ~StructTypeDefs();
  void operator=(const StructTypeDefs& orig);
  ITEXACCESS_DEREF(StructTypeDefs)

  StructTypeDef structTypeDef(int index) const;
  StructTypeDef operator[](int index) const;
};


class ComponentsOf  : public ParseTreeNode
{

public:
  ComponentsOf( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentsOf(const ComponentsOf& orig);
  ~ComponentsOf();
  void operator=(const ComponentsOf& orig);
  ITEXACCESS_DEREF(ComponentsOf)

  ASN1_Type asn1_Type() const;
};


class BitNumber  : public ParseTreeNode
{

public:
  BitNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BitNumber(const BitNumber& orig);
  ~BitNumber();
  void operator=(const BitNumber& orig);
  ITEXACCESS_DEREF(BitNumber)

  Expression expression() const;
};


class AddOp  : public ParseTreeNode
{

public:
  AddOp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AddOp(const AddOp& orig);
  ~AddOp();
  void operator=(const AddOp& orig);
  ITEXACCESS_DEREF(AddOp)

  Plus plus() const;
  Minus minus() const;
  Or or1() const;
  Choices::Choice choice() const;
};


class ValRange  : public ParseTreeNode
{

public:
  ValRange( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValRange(const ValRange& orig);
  ~ValRange();
  void operator=(const ValRange& orig);
  ITEXACCESS_DEREF(ValRange)

  LowerRangeBound lowerRangeBound() const;
  UpperRangeBound upperRangeBound() const;
};


class ASN1_TypeId  : public ParseTreeNode
{

public:
  ASN1_TypeId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_TypeId(const ASN1_TypeId& orig);
  ~ASN1_TypeId();
  void operator=(const ASN1_TypeId& orig);
  ITEXACCESS_DEREF(ASN1_TypeId)

  Identifier asn1_TypeIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class ElemId  : public ParseTreeNode
{

public:
  ElemId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElemId(const ElemId& orig);
  ~ElemId();
  void operator=(const ElemId& orig);
  ITEXACCESS_DEREF(ElemId)

  ElemIdAndFullId elemIdAndFullId() const;
};


class SO_TestMethods  : public TerminalNode
{

public:
  SO_TestMethods( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_TestMethods(const SO_TestMethods& orig);
  ~SO_TestMethods();
  void operator=(const SO_TestMethods& orig);
  ITEXACCESS_DEREF(SO_TestMethods)

};


class Equal  : public TerminalNode
{

public:
  Equal( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Equal(const Equal& orig);
  ~Equal();
  void operator=(const Equal& orig);
  ITEXACCESS_DEREF(Equal)

};


class WithComponent  : public ParseTreeNode
{

public:
  WithComponent( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  WithComponent(const WithComponent& orig);
  ~WithComponent();
  void operator=(const WithComponent& orig);
  ITEXACCESS_DEREF(WithComponent)

  SingleTypeConstraint singleTypeConstraint() const;
};


class ClassNumber  : public ParseTreeNode
{

public:
  ClassNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ClassNumber(const ClassNumber& orig);
  ~ClassNumber();
  void operator=(const ClassNumber& orig);
  ITEXACCESS_DEREF(ClassNumber)

  Number number() const;
  DefinedValue definedValue() const;
  Choices::Choice choice() const;
};


class NamedBitList  : public ParseTreeList
{

public:
  NamedBitList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedBitList(const NamedBitList& orig);
  ~NamedBitList();
  void operator=(const NamedBitList& orig);
  ITEXACCESS_DEREF(NamedBitList)

  NamedNumber namedNumber(int index) const;
  NamedNumber operator[](int index) const;
};


class Repeat  : public ParseTreeNode
{

public:
  Repeat( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Repeat(const Repeat& orig);
  ~Repeat();
  void operator=(const Repeat& orig);
  ITEXACCESS_DEREF(Repeat)

  Attach attach() const;
  Qualifier qualifier() const;
};


class SuiteId  : public ParseTreeNode
{

public:
  SuiteId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SuiteId(const SuiteId& orig);
  ~SuiteId();
  void operator=(const SuiteId& orig);
  ITEXACCESS_DEREF(SuiteId)

  Identifier suiteIdentifier() const;
};


class GreaterOrEqual  : public TerminalNode
{

public:
  GreaterOrEqual( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  GreaterOrEqual(const GreaterOrEqual& orig);
  ~GreaterOrEqual();
  void operator=(const GreaterOrEqual& orig);
  ITEXACCESS_DEREF(GreaterOrEqual)

};


class OPTIONAL  : public TerminalNode
{

public:
  OPTIONAL( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OPTIONAL(const OPTIONAL& orig);
  ~OPTIONAL();
  void operator=(const OPTIONAL& orig);
  ITEXACCESS_DEREF(OPTIONAL)

};


class PDU_FieldType  : public ParseTreeNode
{

public:
  PDU_FieldType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldType(const PDU_FieldType& orig);
  ~PDU_FieldType();
  void operator=(const PDU_FieldType& orig);
  ITEXACCESS_DEREF(PDU_FieldType)

  TypeAndAttributes typeAndAttributes() const;
};


class PCOs_Used  : public ParseTreeNode
{

public:
  PCOs_Used( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCOs_Used(const PCOs_Used& orig);
  ~PCOs_Used();
  void operator=(const PCOs_Used& orig);
  ITEXACCESS_DEREF(PCOs_Used)

  PCO_List pco_List() const;
};


class SO_DefaultRef  : public TerminalNode
{

public:
  SO_DefaultRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_DefaultRef(const SO_DefaultRef& orig);
  ~SO_DefaultRef();
  void operator=(const SO_DefaultRef& orig);
  ITEXACCESS_DEREF(SO_DefaultRef)

};


class ObjectType  : public ParseTreeNode
{

public:
  ObjectType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjectType(const ObjectType& orig);
  ~ObjectType();
  void operator=(const ObjectType& orig);
  ITEXACCESS_DEREF(ObjectType)

  Identifier objectIdentifier() const;
};


class DefaultIdAndParList  : public ParseTreeNode
{

public:
  DefaultIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultIdAndParList(const DefaultIdAndParList& orig);
  ~DefaultIdAndParList();
  void operator=(const DefaultIdAndParList& orig);
  ITEXACCESS_DEREF(DefaultIdAndParList)

  Identifier defaultIdentifier() const;
  FormalParList formalParList() const;
};


class CM_ParType  : public ParseTreeNode
{

public:
  CM_ParType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CM_ParType(const CM_ParType& orig);
  ~CM_ParType();
  void operator=(const CM_ParType& orig);
  ITEXACCESS_DEREF(CM_ParType)

  TypeAndAttributes typeAndAttributes() const;
};


class ChoiceValue  : public ParseTreeNode
{

public:
  ChoiceValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ChoiceValue(const ChoiceValue& orig);
  ~ChoiceValue();
  void operator=(const ChoiceValue& orig);
  ITEXACCESS_DEREF(ChoiceValue)

  NamedValue namedValue() const;
};


class ElemValues  : public RowList
{

public:
  ElemValues( NodeInfo nodeinfo,  Table* tab);
  ElemValues(const ElemValues& orig);
  ~ElemValues();
  void operator=(const ElemValues& orig);
  ITEXACCESS_DEREF(ElemValues)

  ElemValue elemValue(int index) const;
  ElemValue operator[](int index) const;
};


class ConsId  : public ParseTreeNode
{

public:
  ConsId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConsId(const ConsId& orig);
  ~ConsId();
  void operator=(const ConsId& orig);
  ITEXACCESS_DEREF(ConsId)

  ConsIdAndParList consIdAndParList() const;
};


class ASN1_TypeRefs  : public TableNode
{

public:
  ASN1_TypeRefs( NodeInfo nodeinfo);
  ASN1_TypeRefs(const ASN1_TypeRefs& orig);
  ~ASN1_TypeRefs();
  void operator=(const ASN1_TypeRefs& orig);
  ITEXACCESS_DEREF(ASN1_TypeRefs)

  ASN1_TypeRefList asn1_TypeRefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SuiteStructure  : public TableNode
{

public:
  SuiteStructure( NodeInfo nodeinfo);
  SuiteStructure(const SuiteStructure& orig);
  ~SuiteStructure();
  void operator=(const SuiteStructure& orig);
  ITEXACCESS_DEREF(SuiteStructure)

  SO_SuiteId SO_suiteId() const;
  SO_StandardsRef SO_standardsRef() const;
  SO_PICSRef SO_picsRef() const;
  SO_PIXITRef SO_pixitRef() const;
  SO_TestMethods SO_testMethods() const;
  Comment comment() const;
  SO_StructureAndObjectives SO_structureAndObjectives() const;
  DetailedComment detailedComment() const;

  Boolean is_present_SO_suiteId() const;
  Boolean is_present_SO_standardsRef() const;
  Boolean is_present_SO_picsRef() const;
  Boolean is_present_SO_pixitRef() const;
  Boolean is_present_SO_testMethods() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class VariationReference  : public TerminalNode
{

public:
  VariationReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VariationReference(const VariationReference& orig);
  ~VariationReference();
  void operator=(const VariationReference& orig);
  ITEXACCESS_DEREF(VariationReference)

};


class TS_ParId  : public ParseTreeNode
{

public:
  TS_ParId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ParId(const TS_ParId& orig);
  ~TS_ParId();
  void operator=(const TS_ParId& orig);
  ITEXACCESS_DEREF(TS_ParId)

  Identifier ts_ParIdentifier() const;
};


class NullType  : public TerminalNode
{

public:
  NullType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NullType(const NullType& orig);
  ~NullType();
  void operator=(const NullType& orig);
  ITEXACCESS_DEREF(NullType)

};


class Min  : public TerminalNode
{

public:
  Min( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Min(const Min& orig);
  ~Min();
  void operator=(const Min& orig);
  ITEXACCESS_DEREF(Min)

};


class NamedTypeOrSelection  : public ParseTreeNode
{

public:
  NamedTypeOrSelection( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedTypeOrSelection(const NamedTypeOrSelection& orig);
  ~NamedTypeOrSelection();
  void operator=(const NamedTypeOrSelection& orig);
  ITEXACCESS_DEREF(NamedTypeOrSelection)

  NamedType namedType() const;
  SelectionType selectionType() const;
  Choices::Choice choice() const;
};


class CM_ParId  : public ParseTreeNode
{

public:
  CM_ParId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CM_ParId(const CM_ParId& orig);
  ~CM_ParId();
  void operator=(const CM_ParId& orig);
  ITEXACCESS_DEREF(CM_ParId)

  CM_ParIdOrMacro cm_ParIdOrMacro() const;
};


class Mantissa  : public ParseTreeNode
{

public:
  Mantissa( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Mantissa(const Mantissa& orig);
  ~Mantissa();
  void operator=(const Mantissa& orig);
  ITEXACCESS_DEREF(Mantissa)

  SignedNumber signedNumber() const;
  Number number() const;
  Choices::Choice choice() const;
};


class R_Value  : public ParseTreeNode
{

public:
  R_Value( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  R_Value(const R_Value& orig);
  ~R_Value();
  void operator=(const R_Value& orig);
  ITEXACCESS_DEREF(R_Value)

  PASS pass() const;
  FAIL fail() const;
  INCONC inconc() const;
  NONE none() const;
  Choices::Choice choice() const;
};


class CM_Constraints  : public StaticNode
{

public:
  CM_Constraints( NodeInfo nodeinfo);
  CM_Constraints(const CM_Constraints& orig);
  ~CM_Constraints();
  void operator=(const CM_Constraints& orig);
  ITEXACCESS_DEREF(CM_Constraints)

  TTCN_CM_Constraints ttcn_CM_Constraints() const;
  ASN1_CM_Constraints asn1_CM_Constraints() const;
};


class AliasDefs  : public TableNode
{

public:
  AliasDefs( NodeInfo nodeinfo);
  AliasDefs(const AliasDefs& orig);
  ~AliasDefs();
  void operator=(const AliasDefs& orig);
  ITEXACCESS_DEREF(AliasDefs)

  AliasDefList aliasDefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class PCO_TypeDcls  : public TableNode
{

public:
  PCO_TypeDcls( NodeInfo nodeinfo);
  PCO_TypeDcls(const PCO_TypeDcls& orig);
  ~PCO_TypeDcls();
  void operator=(const PCO_TypeDcls& orig);
  ITEXACCESS_DEREF(PCO_TypeDcls)

  PCO_TypeDclList pco_TypeDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SimpleTypeId  : public ParseTreeNode
{

public:
  SimpleTypeId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SimpleTypeId(const SimpleTypeId& orig);
  ~SimpleTypeId();
  void operator=(const SimpleTypeId& orig);
  ITEXACCESS_DEREF(SimpleTypeId)

  Identifier simpleTypeIdentifier() const;
};


class EncVariationId  : public ParseTreeNode
{

public:
  EncVariationId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncVariationId(const EncVariationId& orig);
  ~EncVariationId();
  void operator=(const EncVariationId& orig);
  ITEXACCESS_DEREF(EncVariationId)

  EncVariationCall encVariationCall() const;
};


class SO_TestCaseId  : public TerminalNode
{

public:
  SO_TestCaseId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_TestCaseId(const SO_TestCaseId& orig);
  ~SO_TestCaseId();
  void operator=(const SO_TestCaseId& orig);
  ITEXACCESS_DEREF(SO_TestCaseId)

};


class VideotexString  : public TerminalNode
{

public:
  VideotexString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VideotexString(const VideotexString& orig);
  ~VideotexString();
  void operator=(const VideotexString& orig);
  ITEXACCESS_DEREF(VideotexString)

};


class SubType  : public ParseTreeNode
{

public:
  SubType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SubType(const SubType& orig);
  ~SubType();
  void operator=(const SubType& orig);
  ITEXACCESS_DEREF(SubType)

  ParentSubType parentSubType() const;
  SetSubType setSubType() const;
  SequenceSubType sequenceSubType() const;
  Choices::Choice choice() const;
};


class Primary  : public ParseTreeNode
{

public:
  Primary( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Primary(const Primary& orig);
  ~Primary();
  void operator=(const Primary& orig);
  ITEXACCESS_DEREF(Primary)

  Value value() const;
  DataObjectReference dataObjectReference() const;
  OpCall opCall() const;
  ConsRef consRef() const;
  SelectExprId selectExprId() const;
  ParenExpression parenExpression() const;
  Choices::Choice choice() const;
};


class DefaultGroup  : public TableNode
{

public:
  DefaultGroup( NodeInfo nodeinfo);
  DefaultGroup(const DefaultGroup& orig);
  ~DefaultGroup();
  void operator=(const DefaultGroup& orig);
  ITEXACCESS_DEREF(DefaultGroup)

  DefaultGroupId defaultGroupId() const;
  DefaultGroupOrDefaultList defaultGroupOrDefaultList() const;

  Boolean is_present_defaultGroupId() const;
};


class ASP_ParId  : public ParseTreeNode
{

public:
  ASP_ParId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_ParId(const ASP_ParId& orig);
  ~ASP_ParId();
  void operator=(const ASP_ParId& orig);
  ITEXACCESS_DEREF(ASP_ParId)

  ASP_ParIdOrMacro asp_ParIdOrMacro() const;
};


class TC_VarDclList  : public StaticList
{

public:
  TC_VarDclList( NodeInfo nodeinfo);
  TC_VarDclList(const TC_VarDclList& orig);
  ~TC_VarDclList();
  void operator=(const TC_VarDclList& orig);
  ITEXACCESS_DEREF(TC_VarDclList)

  TC_VarDcl tc_VarDcl(int index) const;
  TC_VarDcl operator[](int index) const;
};


class ATrue  : public TerminalNode
{

public:
  ATrue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ATrue(const ATrue& orig);
  ~ATrue();
  void operator=(const ATrue& orig);
  ITEXACCESS_DEREF(ATrue)

};


class VisibleString  : public TerminalNode
{

public:
  VisibleString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VisibleString(const VisibleString& orig);
  ~VisibleString();
  void operator=(const VisibleString& orig);
  ITEXACCESS_DEREF(VisibleString)

};


class ContainedSubType  : public ParseTreeNode
{

public:
  ContainedSubType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ContainedSubType(const ContainedSubType& orig);
  ~ContainedSubType();
  void operator=(const ContainedSubType& orig);
  ITEXACCESS_DEREF(ContainedSubType)

  ASN1_Type asn1_Type() const;
};


class BooleanValue  : public ParseTreeNode
{

public:
  BooleanValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BooleanValue(const BooleanValue& orig);
  ~BooleanValue();
  void operator=(const BooleanValue& orig);
  ITEXACCESS_DEREF(BooleanValue)

  ATrue Atrue() const;
  AFalse Afalse() const;
  Choices::Choice choice() const;
};


class TS_VarDcl  : public TableNode
{

public:
  TS_VarDcl( NodeInfo nodeinfo);
  TS_VarDcl(const TS_VarDcl& orig);
  ~TS_VarDcl();
  void operator=(const TS_VarDcl& orig);
  ITEXACCESS_DEREF(TS_VarDcl)

  TS_VarId ts_VarId() const;
  TS_VarType ts_VarType() const;
  TS_VarValue ts_VarValue() const;
  Comment comment() const;

  Boolean is_present_ts_VarId() const;
  Boolean is_present_ts_VarType() const;
  Boolean is_present_ts_VarValue() const;
  Boolean is_present_comment() const;
};


class ASN1_ValueReference  : public TerminalNode
{

public:
  ASN1_ValueReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_ValueReference(const ASN1_ValueReference& orig);
  ~ASN1_ValueReference();
  void operator=(const ASN1_ValueReference& orig);
  ITEXACCESS_DEREF(ASN1_ValueReference)

};


class UsefulType  : public ParseTreeNode
{

public:
  UsefulType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UsefulType(const UsefulType& orig);
  ~UsefulType();
  void operator=(const UsefulType& orig);
  ITEXACCESS_DEREF(UsefulType)

  GeneralizedTime generalizedTime() const;
  UTCTime utcTime() const;
  EXTERNAL external() const;
  ObjectDescriptor objectDescriptor() const;
  Choices::Choice choice() const;
};


class AliasId  : public ParseTreeNode
{

public:
  AliasId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AliasId(const AliasId& orig);
  ~AliasId();
  void operator=(const AliasId& orig);
  ITEXACCESS_DEREF(AliasId)

  Identifier aliasIdentifier() const;
};


class ASP_TypeDefs  : public StaticNode
{

public:
  ASP_TypeDefs( NodeInfo nodeinfo);
  ASP_TypeDefs(const ASP_TypeDefs& orig);
  ~ASP_TypeDefs();
  void operator=(const ASP_TypeDefs& orig);
  ITEXACCESS_DEREF(ASP_TypeDefs)

  TTCN_ASP_TypeDefs ttcn_ASP_TypeDefs() const;
  ASN1_ASP_TypeDefs asn1_ASP_TypeDefs() const;
  ASN1_ASP_TypeDefsByRef asn1_ASP_TypeDefsByRef() const;
};


class BITSTRING  : public TerminalNode
{

public:
  BITSTRING( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BITSTRING(const BITSTRING& orig);
  ~BITSTRING();
  void operator=(const BITSTRING& orig);
  ITEXACCESS_DEREF(BITSTRING)

};


class ChoiceType  : public ParseTreeNode
{

public:
  ChoiceType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ChoiceType(const ChoiceType& orig);
  ~ChoiceType();
  void operator=(const ChoiceType& orig);
  ITEXACCESS_DEREF(ChoiceType)

  AlternativeTypeList alternativeTypeList() const;
};


class Encoding_TypeList  : public TerminalNode
{

public:
  Encoding_TypeList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Encoding_TypeList(const Encoding_TypeList& orig);
  ~Encoding_TypeList();
  void operator=(const Encoding_TypeList& orig);
  ITEXACCESS_DEREF(Encoding_TypeList)

};


class DefaultReference  : public ParseTreeNode
{

public:
  DefaultReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultReference(const DefaultReference& orig);
  ~DefaultReference();
  void operator=(const DefaultReference& orig);
  ITEXACCESS_DEREF(DefaultReference)

  Identifier defaultIdentifier() const;
  ActualParList actualParList() const;
};


class TS_VarType  : public ParseTreeNode
{

public:
  TS_VarType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_VarType(const TS_VarType& orig);
  ~TS_VarType();
  void operator=(const TS_VarType& orig);
  ITEXACCESS_DEREF(TS_VarType)

  TypeOrPDU typeOrPDU() const;
};


class TypeOrPDU  : public ParseTreeNode
{

public:
  TypeOrPDU( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeOrPDU(const TypeOrPDU& orig);
  ~TypeOrPDU();
  void operator=(const TypeOrPDU& orig);
  ITEXACCESS_DEREF(TypeOrPDU)

  TTCN_Type ttcn_Type() const;
  PDU pdu() const;
  Choices::Choice choice() const;
};


class GeneralString  : public TerminalNode
{

public:
  GeneralString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  GeneralString(const GeneralString& orig);
  ~GeneralString();
  void operator=(const GeneralString& orig);
  ITEXACCESS_DEREF(GeneralString)

};


class Cstring  : public TerminalNode
{

public:
  Cstring( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Cstring(const Cstring& orig);
  ~Cstring();
  void operator=(const Cstring& orig);
  ITEXACCESS_DEREF(Cstring)

};


class ParentType  : public ParseTreeNode
{

public:
  ParentType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ParentType(const ParentType& orig);
  ~ParentType();
  void operator=(const ParentType& orig);
  ITEXACCESS_DEREF(ParentType)

  ASN1_Type asn1_Type() const;
};


class ComponentPosition  : public ParseTreeNode
{

public:
  ComponentPosition( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentPosition(const ComponentPosition& orig);
  ~ComponentPosition();
  void operator=(const ComponentPosition& orig);
  ITEXACCESS_DEREF(ComponentPosition)

  Number number() const;
};


class EventStatement  : public ParseTreeNode
{

public:
  EventStatement( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EventStatement(const EventStatement& orig);
  ~EventStatement();
  void operator=(const EventStatement& orig);
  ITEXACCESS_DEREF(EventStatement)

  Event event() const;
  Qualifier qualifier() const;
  AssignmentList assignmentList() const;
  TimerOps timerOps() const;

  Boolean is_present_event() const;
  Boolean is_present_qualifier() const;
};


class TCompUsed  : public ParseTreeNode
{

public:
  TCompUsed( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TCompUsed(const TCompUsed& orig);
  ~TCompUsed();
  void operator=(const TCompUsed& orig);
  ITEXACCESS_DEREF(TCompUsed)

  Identifier tcompIdentifier() const;
};


class LessOrEqual  : public TerminalNode
{

public:
  LessOrEqual( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LessOrEqual(const LessOrEqual& orig);
  ~LessOrEqual();
  void operator=(const LessOrEqual& orig);
  ITEXACCESS_DEREF(LessOrEqual)

};


class Less  : public TerminalNode
{

public:
  Less( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Less(const Less& orig);
  ~Less();
  void operator=(const Less& orig);
  ITEXACCESS_DEREF(Less)

};


class OMIT  : public TerminalNode
{

public:
  OMIT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OMIT(const OMIT& orig);
  ~OMIT();
  void operator=(const OMIT& orig);
  ITEXACCESS_DEREF(OMIT)

};


class TestStepIdAndParList  : public ParseTreeNode
{

public:
  TestStepIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepIdAndParList(const TestStepIdAndParList& orig);
  ~TestStepIdAndParList();
  void operator=(const TestStepIdAndParList& orig);
  ITEXACCESS_DEREF(TestStepIdAndParList)

  Identifier testStepIdentifier() const;
  FormalParList formalParList() const;
};


class Activate  : public ParseTreeNode
{

public:
  Activate( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Activate(const Activate& orig);
  ~Activate();
  void operator=(const Activate& orig);
  ITEXACCESS_DEREF(Activate)

  DefaultRefList defaultRefList() const;
};


class ASN1_TypeDef  : public TableNode
{

public:
  ASN1_TypeDef( NodeInfo nodeinfo);
  ASN1_TypeDef(const ASN1_TypeDef& orig);
  ~ASN1_TypeDef();
  void operator=(const ASN1_TypeDef& orig);
  ITEXACCESS_DEREF(ASN1_TypeDef)

  ASN1_TypeId asn1_TypeId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;
  DetailedComment detailedComment() const;

  Boolean is_present_asn1_TypeId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
  Boolean is_present_detailedComment() const;
};


class RealType  : public TerminalNode
{

public:
  RealType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RealType(const RealType& orig);
  ~RealType();
  void operator=(const RealType& orig);
  ITEXACCESS_DEREF(RealType)

};


class NamedConstraintList  : public ParseTreeList
{

public:
  NamedConstraintList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedConstraintList(const NamedConstraintList& orig);
  ~NamedConstraintList();
  void operator=(const NamedConstraintList& orig);
  ITEXACCESS_DEREF(NamedConstraintList)

  NamedConstraint namedConstraint(int index) const;
  NamedConstraint operator[](int index) const;
};


class SingleTypeConstraint  : public ParseTreeNode
{

public:
  SingleTypeConstraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SingleTypeConstraint(const SingleTypeConstraint& orig);
  ~SingleTypeConstraint();
  void operator=(const SingleTypeConstraint& orig);
  ITEXACCESS_DEREF(SingleTypeConstraint)

  SubTypeSpec subTypeSpec() const;
};


class ASN1_CM_Constraint  : public TableNode
{

public:
  ASN1_CM_Constraint( NodeInfo nodeinfo);
  ASN1_CM_Constraint(const ASN1_CM_Constraint& orig);
  ~ASN1_CM_Constraint();
  void operator=(const ASN1_CM_Constraint& orig);
  ITEXACCESS_DEREF(ASN1_CM_Constraint)

  ConsId consId() const;
  CM_Id cm_Id() const;
  DerivPath derivPath() const;
  Comment comment() const;
  ASN1_ConsValue asn1_ConsValue() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_cm_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_ConsValue() const;
  Boolean is_present_detailedComment() const;
};


class TS_OpDefs  : public StaticList
{

public:
  TS_OpDefs( NodeInfo nodeinfo);
  TS_OpDefs(const TS_OpDefs& orig);
  ~TS_OpDefs();
  void operator=(const TS_OpDefs& orig);
  ITEXACCESS_DEREF(TS_OpDefs)

  TS_OpDef ts_OpDef(int index) const;
  TS_OpDef operator[](int index) const;
};


class Div  : public TerminalNode
{

public:
  Div( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Div(const Div& orig);
  ~Div();
  void operator=(const Div& orig);
  ITEXACCESS_DEREF(Div)

};


class TTCN_PDU_TypeDef  : public TableNode
{

public:
  TTCN_PDU_TypeDef( NodeInfo nodeinfo);
  TTCN_PDU_TypeDef(const TTCN_PDU_TypeDef& orig);
  ~TTCN_PDU_TypeDef();
  void operator=(const TTCN_PDU_TypeDef& orig);
  ITEXACCESS_DEREF(TTCN_PDU_TypeDef)

  PDU_Id pdu_Id() const;
  PCO_Type pco_Type() const;
  PDU_EncodingId pdu_EncodingId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  PDU_FieldDcls pdu_FieldDcls() const;
  DetailedComment detailedComment() const;

  Boolean is_present_pdu_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_pdu_EncodingId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class SO_TestStepId  : public TerminalNode
{

public:
  SO_TestStepId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_TestStepId(const SO_TestStepId& orig);
  ~SO_TestStepId();
  void operator=(const SO_TestStepId& orig);
  ITEXACCESS_DEREF(SO_TestStepId)

};


class Mod  : public TerminalNode
{

public:
  Mod( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Mod(const Mod& orig);
  ~Mod();
  void operator=(const Mod& orig);
  ITEXACCESS_DEREF(Mod)

};


class ValueAttributes  : public ParseTreeNode
{

public:
  ValueAttributes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueAttributes(const ValueAttributes& orig);
  ~ValueAttributes();
  void operator=(const ValueAttributes& orig);
  ITEXACCESS_DEREF(ValueAttributes)

  ValueLength valueLength() const;
  IF_PRESENT if_PRESENT() const;

  Boolean is_present_valueLength() const;
  Boolean is_present_if_PRESENT() const;
};


class LowerBound  : public ParseTreeNode
{

public:
  LowerBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerBound(const LowerBound& orig);
  ~LowerBound();
  void operator=(const LowerBound& orig);
  ITEXACCESS_DEREF(LowerBound)

  Bound bound() const;
};


class PicoSeconds  : public TerminalNode
{

public:
  PicoSeconds( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PicoSeconds(const PicoSeconds& orig);
  ~PicoSeconds();
  void operator=(const PicoSeconds& orig);
  ITEXACCESS_DEREF(PicoSeconds)

};


class FormalParType  : public ParseTreeNode
{

public:
  FormalParType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FormalParType(const FormalParType& orig);
  ~FormalParType();
  void operator=(const FormalParType& orig);
  ITEXACCESS_DEREF(FormalParType)

  TTCN_Type ttcn_Type() const;
  PDU pdu() const;
  CP cp() const;
  TIMER timer() const;
  Choices::Choice choice() const;
};


class ASN1_ASP_TypeDef  : public TableNode
{

public:
  ASN1_ASP_TypeDef( NodeInfo nodeinfo);
  ASN1_ASP_TypeDef(const ASN1_ASP_TypeDef& orig);
  ~ASN1_ASP_TypeDef();
  void operator=(const ASN1_ASP_TypeDef& orig);
  ITEXACCESS_DEREF(ASN1_ASP_TypeDef)

  ASP_Id asp_Id() const;
  PCO_Type pco_Type() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;
  DetailedComment detailedComment() const;

  Boolean is_present_asp_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
  Boolean is_present_detailedComment() const;
};


class TimerDcls  : public TableNode
{

public:
  TimerDcls( NodeInfo nodeinfo);
  TimerDcls(const TimerDcls& orig);
  ~TimerDcls();
  void operator=(const TimerDcls& orig);
  ITEXACCESS_DEREF(TimerDcls)

  TimerDclList timerDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SelectExprId  : public ParseTreeNode
{

public:
  SelectExprId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelectExprId(const SelectExprId& orig);
  ~SelectExprId();
  void operator=(const SelectExprId& orig);
  ITEXACCESS_DEREF(SelectExprId)

  Identifier selectExprIdentifier() const;
};


class SO_SuiteId  : public ParseTreeNode
{

public:
  SO_SuiteId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_SuiteId(const SO_SuiteId& orig);
  ~SO_SuiteId();
  void operator=(const SO_SuiteId& orig);
  ITEXACCESS_DEREF(SO_SuiteId)

  Identifier suiteIdentifier() const;
};


class SequenceSubType  : public ParseTreeNode
{

public:
  SequenceSubType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SequenceSubType(const SequenceSubType& orig);
  ~SequenceSubType();
  void operator=(const SequenceSubType& orig);
  ITEXACCESS_DEREF(SequenceSubType)

  SizeConstraint sizeConstraint() const;
  ASN1_Type asn1_Type() const;
};


class Attach  : public ParseTreeNode
{

public:
  Attach( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Attach(const Attach& orig);
  ~Attach();
  void operator=(const Attach& orig);
  ITEXACCESS_DEREF(Attach)

  TreeReference treeReference() const;
  ActualParList actualParList() const;
};


class TCompConfigDcls  : public StaticList
{

public:
  TCompConfigDcls( NodeInfo nodeinfo);
  TCompConfigDcls(const TCompConfigDcls& orig);
  ~TCompConfigDcls();
  void operator=(const TCompConfigDcls& orig);
  ITEXACCESS_DEREF(TCompConfigDcls)

  TCompConfigDcl tcompConfigDcl(int index) const;
  TCompConfigDcl operator[](int index) const;
};


class SO_TestGroupRef  : public TerminalNode
{

public:
  SO_TestGroupRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_TestGroupRef(const SO_TestGroupRef& orig);
  ~SO_TestGroupRef();
  void operator=(const SO_TestGroupRef& orig);
  ITEXACCESS_DEREF(SO_TestGroupRef)

};


class Minus  : public TerminalNode
{

public:
  Minus( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Minus(const Minus& orig);
  ~Minus();
  void operator=(const Minus& orig);
  ITEXACCESS_DEREF(Minus)

};


class Num_CPs  : public ParseTreeNode
{

public:
  Num_CPs( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Num_CPs(const Num_CPs& orig);
  ~Num_CPs();
  void operator=(const Num_CPs& orig);
  ITEXACCESS_DEREF(Num_CPs)

  Number number() const;
};


class SimpleTypeDef  : public TableNode
{

public:
  SimpleTypeDef( NodeInfo nodeinfo);
  SimpleTypeDef(const SimpleTypeDef& orig);
  ~SimpleTypeDef();
  void operator=(const SimpleTypeDef& orig);
  ITEXACCESS_DEREF(SimpleTypeDef)

  SimpleTypeId simpleTypeId() const;
  SimpleTypeDefinition simpleTypeDefinition() const;
  PDU_FieldEncoding pdu_FieldEncoding() const;
  Comment comment() const;

  Boolean is_present_simpleTypeId() const;
  Boolean is_present_simpleTypeDefinition() const;
  Boolean is_present_pdu_FieldEncoding() const;
  Boolean is_present_comment() const;
};


class ImportedObjectList  : public StaticList
{

public:
  ImportedObjectList( NodeInfo nodeinfo);
  ImportedObjectList(const ImportedObjectList& orig);
  ~ImportedObjectList();
  void operator=(const ImportedObjectList& orig);
  ITEXACCESS_DEREF(ImportedObjectList)

  ImportedObject importedObject(int index) const;
  ImportedObject operator[](int index) const;
};


class PrintableString  : public TerminalNode
{

public:
  PrintableString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PrintableString(const PrintableString& orig);
  ~PrintableString();
  void operator=(const PrintableString& orig);
  ITEXACCESS_DEREF(PrintableString)

};


class TaggedType  : public ParseTreeNode
{

public:
  TaggedType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TaggedType(const TaggedType& orig);
  ~TaggedType();
  void operator=(const TaggedType& orig);
  ITEXACCESS_DEREF(TaggedType)

  Tag tag() const;
  TagAttributes tagAttributes() const;
  ASN1_Type asn1_Type() const;

  Boolean is_present_tagAttributes() const;
};


class TestStepAttachment  : public ParseTreeNode
{

public:
  TestStepAttachment( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepAttachment(const TestStepAttachment& orig);
  ~TestStepAttachment();
  void operator=(const TestStepAttachment& orig);
  ITEXACCESS_DEREF(TestStepAttachment)

  Attach attach() const;
};


class NONE  : public TerminalNode
{

public:
  NONE( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NONE(const NONE& orig);
  ~NONE();
  void operator=(const NONE& orig);
  ITEXACCESS_DEREF(NONE)

};


class OCTETSTRING  : public TerminalNode
{

public:
  OCTETSTRING( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OCTETSTRING(const OCTETSTRING& orig);
  ~OCTETSTRING();
  void operator=(const OCTETSTRING& orig);
  ITEXACCESS_DEREF(OCTETSTRING)

};


class ObjIdComponent  : public ParseTreeNode
{

public:
  ObjIdComponent( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjIdComponent(const ObjIdComponent& orig);
  ~ObjIdComponent();
  void operator=(const ObjIdComponent& orig);
  ITEXACCESS_DEREF(ObjIdComponent)

  NameForm nameForm() const;
  NumberForm numberForm() const;
  NameAndNumberForm nameAndNumberForm() const;
  Choices::Choice choice() const;
};


class AnyType  : public ParseTreeNode
{

public:
  AnyType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AnyType(const AnyType& orig);
  ~AnyType();
  void operator=(const AnyType& orig);
  ITEXACCESS_DEREF(AnyType)

  ANY any() const;
  AnyDefinedBy anyDefinedBy() const;
  Choices::Choice choice() const;
};


class InvalidFieldEncodingDefinition  : public TerminalNode
{

public:
  InvalidFieldEncodingDefinition( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  InvalidFieldEncodingDefinition(const InvalidFieldEncodingDefinition& orig);
  ~InvalidFieldEncodingDefinition();
  void operator=(const InvalidFieldEncodingDefinition& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingDefinition)

};


class AnyOrOmit  : public TerminalNode
{

public:
  AnyOrOmit( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AnyOrOmit(const AnyOrOmit& orig);
  ~AnyOrOmit();
  void operator=(const AnyOrOmit& orig);
  ITEXACCESS_DEREF(AnyOrOmit)

};


class TIMER  : public TerminalNode
{

public:
  TIMER( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TIMER(const TIMER& orig);
  ~TIMER();
  void operator=(const TIMER& orig);
  ITEXACCESS_DEREF(TIMER)

};


class NamedType  : public ParseTreeNode
{

public:
  NamedType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedType(const NamedType& orig);
  ~NamedType();
  void operator=(const NamedType& orig);
  ITEXACCESS_DEREF(NamedType)

  Identifier identifier() const;
  ASN1_Type asn1_Type() const;
};


class ComponentIdentifier  : public ParseTreeNode
{

public:
  ComponentIdentifier( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentIdentifier(const ComponentIdentifier& orig);
  ~ComponentIdentifier();
  void operator=(const ComponentIdentifier& orig);
  ITEXACCESS_DEREF(ComponentIdentifier)

  Identifier identifier() const;
};


class TS_ConstValue  : public ParseTreeNode
{

public:
  TS_ConstValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ConstValue(const TS_ConstValue& orig);
  ~TS_ConstValue();
  void operator=(const TS_ConstValue& orig);
  ITEXACCESS_DEREF(TS_ConstValue)

  DeclarationValue declarationValue() const;
};


class TS_OpDescription  : public TerminalNode
{

public:
  TS_OpDescription( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_OpDescription(const TS_OpDescription& orig);
  ~TS_OpDescription();
  void operator=(const TS_OpDescription& orig);
  ITEXACCESS_DEREF(TS_OpDescription)

};


class TS_TypeDefs  : public StaticNode
{

public:
  TS_TypeDefs( NodeInfo nodeinfo);
  TS_TypeDefs(const TS_TypeDefs& orig);
  ~TS_TypeDefs();
  void operator=(const TS_TypeDefs& orig);
  ITEXACCESS_DEREF(TS_TypeDefs)

  SimpleTypeDefs simpleTypeDefs() const;
  StructTypeDefs structTypeDefs() const;
  ASN1_TypeDefs asn1_TypeDefs() const;
  ASN1_TypeRefs asn1_TypeRefs() const;
};


class ObjectIdentifierType  : public TerminalNode
{

public:
  ObjectIdentifierType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjectIdentifierType(const ObjectIdentifierType& orig);
  ~ObjectIdentifierType();
  void operator=(const ObjectIdentifierType& orig);
  ITEXACCESS_DEREF(ObjectIdentifierType)

};


class AlternativeTypeList  : public ParseTreeList
{

public:
  AlternativeTypeList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AlternativeTypeList(const AlternativeTypeList& orig);
  ~AlternativeTypeList();
  void operator=(const AlternativeTypeList& orig);
  ITEXACCESS_DEREF(AlternativeTypeList)

  NamedType namedType(int index) const;
  NamedType operator[](int index) const;
};


class UnaryExpression  : public ParseTreeNode
{

public:
  UnaryExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UnaryExpression(const UnaryExpression& orig);
  ~UnaryExpression();
  void operator=(const UnaryExpression& orig);
  ITEXACCESS_DEREF(UnaryExpression)

  UnaryOp unaryOp() const;
  Primary primary() const;
};


class TestStepRef  : public ParseTreeNode
{

public:
  TestStepRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepRef(const TestStepRef& orig);
  ~TestStepRef();
  void operator=(const TestStepRef& orig);
  ITEXACCESS_DEREF(TestStepRef)

  TestStepGroupReference testStepGroupReference() const;
};


class StartTimer  : public ParseTreeNode
{

public:
  StartTimer( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  StartTimer(const StartTimer& orig);
  ~StartTimer();
  void operator=(const StartTimer& orig);
  ITEXACCESS_DEREF(StartTimer)

  Identifier timerIdentifier() const;
  TimerValue timerValue() const;

  Boolean is_present_timerValue() const;
};


class ImplicitSend  : public ParseTreeNode
{

public:
  ImplicitSend( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ImplicitSend(const ImplicitSend& orig);
  ~ImplicitSend();
  void operator=(const ImplicitSend& orig);
  ITEXACCESS_DEREF(ImplicitSend)

  Identifier identifier() const;
};


class PDU_FieldDcls  : public RowList
{

public:
  PDU_FieldDcls( NodeInfo nodeinfo,  Table* tab);
  PDU_FieldDcls(const PDU_FieldDcls& orig);
  ~PDU_FieldDcls();
  void operator=(const PDU_FieldDcls& orig);
  ITEXACCESS_DEREF(PDU_FieldDcls)

  PDU_FieldDcl pdu_FieldDcl(int index) const;
  PDU_FieldDcl operator[](int index) const;
};


class StructIdAndFullId  : public ParseTreeNode
{

public:
  StructIdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  StructIdAndFullId(const StructIdAndFullId& orig);
  ~StructIdAndFullId();
  void operator=(const StructIdAndFullId& orig);
  ITEXACCESS_DEREF(StructIdAndFullId)

  Identifier structIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class EncodingVariation  : public TableNode
{

public:
  EncodingVariation( NodeInfo nodeinfo);
  EncodingVariation(const EncodingVariation& orig);
  ~EncodingVariation();
  void operator=(const EncodingVariation& orig);
  ITEXACCESS_DEREF(EncodingVariation)

  EncodingVariationId encodingVariationId() const;
  VariationRef variationRef() const;
  VariationDefault variationDefault() const;
  Comment comment() const;

  Boolean is_present_encodingVariationId() const;
  Boolean is_present_variationRef() const;
  Boolean is_present_variationDefault() const;
  Boolean is_present_comment() const;
};


class INFINITY  : public TerminalNode
{

public:
  INFINITY( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  INFINITY(const INFINITY& orig);
  ~INFINITY();
  void operator=(const INFINITY& orig);
  ITEXACCESS_DEREF(INFINITY)

};


class DefinedValue  : public ParseTreeNode
{

public:
  DefinedValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefinedValue(const DefinedValue& orig);
  ~DefinedValue();
  void operator=(const DefinedValue& orig);
  ITEXACCESS_DEREF(DefinedValue)

  Identifier identifier() const;
};


class CM_ParDcls  : public RowList
{

public:
  CM_ParDcls( NodeInfo nodeinfo,  Table* tab);
  CM_ParDcls(const CM_ParDcls& orig);
  ~CM_ParDcls();
  void operator=(const CM_ParDcls& orig);
  ITEXACCESS_DEREF(CM_ParDcls)

  CM_ParDcl cm_ParDcl(int index) const;
  CM_ParDcl operator[](int index) const;
};


class SourceName  : public ParseTreeNode
{

public:
  SourceName( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SourceName(const SourceName& orig);
  ~SourceName();
  void operator=(const SourceName& orig);
  ITEXACCESS_DEREF(SourceName)

  Identifier sourceIdentifier() const;
};


class ASN1_TypeRef  : public TableNode
{

public:
  ASN1_TypeRef( NodeInfo nodeinfo);
  ASN1_TypeRef(const ASN1_TypeRef& orig);
  ~ASN1_TypeRef();
  void operator=(const ASN1_TypeRef& orig);
  ITEXACCESS_DEREF(ASN1_TypeRef)

  ASN1_TypeId asn1_TypeId() const;
  ASN1_TypeReference asn1_TypeReference() const;
  ASN1_ModuleId asn1_ModuleId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;

  Boolean is_present_asn1_TypeId() const;
  Boolean is_present_asn1_TypeReference() const;
  Boolean is_present_asn1_ModuleId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
};


class ASN1_TypeAndLocalTypes  : public ParseTreeNode
{

public:
  ASN1_TypeAndLocalTypes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_TypeAndLocalTypes(const ASN1_TypeAndLocalTypes& orig);
  ~ASN1_TypeAndLocalTypes();
  void operator=(const ASN1_TypeAndLocalTypes& orig);
  ITEXACCESS_DEREF(ASN1_TypeAndLocalTypes)

  ASN1_Type asn1_Type() const;
  ASN1_LocalTypes asn1_LocalTypes() const;
};


class TestGroupOrTestCaseList  : public StaticList
{

public:
  TestGroupOrTestCaseList( NodeInfo nodeinfo);
  TestGroupOrTestCaseList(const TestGroupOrTestCaseList& orig);
  ~TestGroupOrTestCaseList();
  void operator=(const TestGroupOrTestCaseList& orig);
  ITEXACCESS_DEREF(TestGroupOrTestCaseList)

  TestGroupOrTestCase testGroupOrTestCase(int index) const;
  TestGroupOrTestCase operator[](int index) const;
};


class MacroSymbol  : public TerminalNode
{

public:
  MacroSymbol( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MacroSymbol(const MacroSymbol& orig);
  ~MacroSymbol();
  void operator=(const MacroSymbol& orig);
  ITEXACCESS_DEREF(MacroSymbol)

};


class ASN1_LocalTypes  : public ParseTreeNode
{

public:
  ASN1_LocalTypes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_LocalTypes(const ASN1_LocalTypes& orig);
  ~ASN1_LocalTypes();
  void operator=(const ASN1_LocalTypes& orig);
  ITEXACCESS_DEREF(ASN1_LocalTypes)

  TypeAssignmentList typeAssignmentList() const;
};


class ASN1_CM_TypeDefs  : public StaticList
{

public:
  ASN1_CM_TypeDefs( NodeInfo nodeinfo);
  ASN1_CM_TypeDefs(const ASN1_CM_TypeDefs& orig);
  ~ASN1_CM_TypeDefs();
  void operator=(const ASN1_CM_TypeDefs& orig);
  ITEXACCESS_DEREF(ASN1_CM_TypeDefs)

  ASN1_CM_TypeDef asn1_CM_TypeDef(int index) const;
  ASN1_CM_TypeDef operator[](int index) const;
};


class ASP_IdAndFullId  : public ParseTreeNode
{

public:
  ASP_IdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_IdAndFullId(const ASP_IdAndFullId& orig);
  ~ASP_IdAndFullId();
  void operator=(const ASP_IdAndFullId& orig);
  ITEXACCESS_DEREF(ASP_IdAndFullId)

  Identifier asp_Identifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class NumOf_PCOs  : public ParseTreeNode
{

public:
  NumOf_PCOs( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NumOf_PCOs(const NumOf_PCOs& orig);
  ~NumOf_PCOs();
  void operator=(const NumOf_PCOs& orig);
  ITEXACCESS_DEREF(NumOf_PCOs)

  Num_PCOs num_PCOs() const;
};


class SO_PICSRef  : public TerminalNode
{

public:
  SO_PICSRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_PICSRef(const SO_PICSRef& orig);
  ~SO_PICSRef();
  void operator=(const SO_PICSRef& orig);
  ITEXACCESS_DEREF(SO_PICSRef)

};


class DetailedComment  : public TerminalNode
{

public:
  DetailedComment( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DetailedComment(const DetailedComment& orig);
  ~DetailedComment();
  void operator=(const DetailedComment& orig);
  ITEXACCESS_DEREF(DetailedComment)

};


class Greater  : public TerminalNode
{

public:
  Greater( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Greater(const Greater& orig);
  ~Greater();
  void operator=(const Greater& orig);
  ITEXACCESS_DEREF(Greater)

};


class UTCTime  : public TerminalNode
{

public:
  UTCTime( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UTCTime(const UTCTime& orig);
  ~UTCTime();
  void operator=(const UTCTime& orig);
  ITEXACCESS_DEREF(UTCTime)

};


class TCompConfigId  : public ParseTreeNode
{

public:
  TCompConfigId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TCompConfigId(const TCompConfigId& orig);
  ~TCompConfigId();
  void operator=(const TCompConfigId& orig);
  ITEXACCESS_DEREF(TCompConfigId)

  Identifier tcompConfigIdentifier() const;
};


class SO_PIXITRef  : public TerminalNode
{

public:
  SO_PIXITRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_PIXITRef(const SO_PIXITRef& orig);
  ~SO_PIXITRef();
  void operator=(const SO_PIXITRef& orig);
  ITEXACCESS_DEREF(SO_PIXITRef)

};


class SimpleValue  : public ParseTreeNode
{

public:
  SimpleValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SimpleValue(const SimpleValue& orig);
  ~SimpleValue();
  void operator=(const SimpleValue& orig);
  ITEXACCESS_DEREF(SimpleValue)

  LiteralValue literalValue() const;
  SignedNumber signedNumber() const;
  Choices::Choice choice() const;
};


class SelectExprDefs  : public TableNode
{

public:
  SelectExprDefs( NodeInfo nodeinfo);
  SelectExprDefs(const SelectExprDefs& orig);
  ~SelectExprDefs();
  void operator=(const SelectExprDefs& orig);
  ITEXACCESS_DEREF(SelectExprDefs)

  SelectExprDefList selectExprDefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class EncodingDefs  : public StaticNode
{

public:
  EncodingDefs( NodeInfo nodeinfo);
  EncodingDefs(const EncodingDefs& orig);
  ~EncodingDefs();
  void operator=(const EncodingDefs& orig);
  ITEXACCESS_DEREF(EncodingDefs)

  EncodingDefinitions encodingDefinitions() const;
  EncodingVariations encodingVariations() const;
  InvalidFieldEncodingDefs invalidFieldEncodingDefs() const;
};


class TS_ProcResult  : public ParseTreeNode
{

public:
  TS_ProcResult( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ProcResult(const TS_ProcResult& orig);
  ~TS_ProcResult();
  void operator=(const TS_ProcResult& orig);
  ITEXACCESS_DEREF(TS_ProcResult)

  TTCN_Type ttcn_Type() const;
};


class TreeHeader  : public ParseTreeNode
{

public:
  TreeHeader( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TreeHeader(const TreeHeader& orig);
  ~TreeHeader();
  void operator=(const TreeHeader& orig);
  ITEXACCESS_DEREF(TreeHeader)

  Identifier treeIdentifier() const;
  FormalParList formalParList() const;
};


class TestGroupOrTestCase  : public StaticNode
{

public:
  TestGroupOrTestCase( NodeInfo nodeinfo);
  TestGroupOrTestCase(const TestGroupOrTestCase& orig);
  ~TestGroupOrTestCase();
  void operator=(const TestGroupOrTestCase& orig);
  ITEXACCESS_DEREF(TestGroupOrTestCase)

  TestGroup testGroup() const;
  TestCase testCase() const;
  CompactTestGroup compactTestGroup() const;
  Choices::Choice choice() const;
};


class PCO_Id  : public ParseTreeNode
{

public:
  PCO_Id( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCO_Id(const PCO_Id& orig);
  ~PCO_Id();
  void operator=(const PCO_Id& orig);
  ITEXACCESS_DEREF(PCO_Id)

  Identifier pco_Identifier() const;
};


class TS_ConstId  : public ParseTreeNode
{

public:
  TS_ConstId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ConstId(const TS_ConstId& orig);
  ~TS_ConstId();
  void operator=(const TS_ConstId& orig);
  ITEXACCESS_DEREF(TS_ConstId)

  Identifier ts_ConstIdentifier() const;
};


class IntegerRange  : public ParseTreeNode
{

public:
  IntegerRange( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IntegerRange(const IntegerRange& orig);
  ~IntegerRange();
  void operator=(const IntegerRange& orig);
  ITEXACCESS_DEREF(IntegerRange)

  LowerTypeBound lowerTypeBound() const;
  UpperTypeBound upperTypeBound() const;
};


class CompactTestCaseList  : public StaticList
{

public:
  CompactTestCaseList( NodeInfo nodeinfo);
  CompactTestCaseList(const CompactTestCaseList& orig);
  ~CompactTestCaseList();
  void operator=(const CompactTestCaseList& orig);
  ITEXACCESS_DEREF(CompactTestCaseList)

  CompactTestCase compactTestCase(int index) const;
  CompactTestCase operator[](int index) const;
};


class ASN1_ModuleId  : public TerminalNode
{

public:
  ASN1_ModuleId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_ModuleId(const ASN1_ModuleId& orig);
  ~ASN1_ModuleId();
  void operator=(const ASN1_ModuleId& orig);
  ITEXACCESS_DEREF(ASN1_ModuleId)

};


class ElemIdAndFullId  : public ParseTreeNode
{

public:
  ElemIdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElemIdAndFullId(const ElemIdAndFullId& orig);
  ~ElemIdAndFullId();
  void operator=(const ElemIdAndFullId& orig);
  ITEXACCESS_DEREF(ElemIdAndFullId)

  Identifier elemIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class INTEGER  : public TerminalNode
{

public:
  INTEGER( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  INTEGER(const INTEGER& orig);
  ~INTEGER();
  void operator=(const INTEGER& orig);
  ITEXACCESS_DEREF(INTEGER)

};


class Line  : public ParseTreeRowNode
{

public:
  Line( NodeInfo nodeinfo,  Table* tab,  Row* row,  Field* field,  PT* pt);
  Line(const Line& orig);
  ~Line();
  void operator=(const Line& orig);
  ITEXACCESS_DEREF(Line)

  Indentation indentation() const;
  StatementLine statementLine() const;
};


class TTCN_PDU_Constraints  : public StaticList
{

public:
  TTCN_PDU_Constraints( NodeInfo nodeinfo);
  TTCN_PDU_Constraints(const TTCN_PDU_Constraints& orig);
  ~TTCN_PDU_Constraints();
  void operator=(const TTCN_PDU_Constraints& orig);
  ITEXACCESS_DEREF(TTCN_PDU_Constraints)

  TTCN_PDU_Constraint ttcn_PDU_Constraint(int index) const;
  TTCN_PDU_Constraint operator[](int index) const;
};


class PCO_TypeDcl  : public TableNode
{

public:
  PCO_TypeDcl( NodeInfo nodeinfo);
  PCO_TypeDcl(const PCO_TypeDcl& orig);
  ~PCO_TypeDcl();
  void operator=(const PCO_TypeDcl& orig);
  ITEXACCESS_DEREF(PCO_TypeDcl)

  PCO_TypeId pco_TypeId() const;
  P_Role p_Role() const;
  Comment comment() const;

  Boolean is_present_pco_TypeId() const;
  Boolean is_present_p_Role() const;
  Boolean is_present_comment() const;
};


class TS_ConstRefs  : public TableNode
{

public:
  TS_ConstRefs( NodeInfo nodeinfo);
  TS_ConstRefs(const TS_ConstRefs& orig);
  ~TS_ConstRefs();
  void operator=(const TS_ConstRefs& orig);
  ITEXACCESS_DEREF(TS_ConstRefs)

  TS_ConstRefList ts_ConstRefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SingleLength  : public ParseTreeNode
{

public:
  SingleLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SingleLength(const SingleLength& orig);
  ~SingleLength();
  void operator=(const SingleLength& orig);
  ITEXACCESS_DEREF(SingleLength)

  Bound bound() const;
};


class UpperTypeBound  : public ParseTreeNode
{

public:
  UpperTypeBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperTypeBound(const UpperTypeBound& orig);
  ~UpperTypeBound();
  void operator=(const UpperTypeBound& orig);
  ITEXACCESS_DEREF(UpperTypeBound)

  SignedNumber signedNumber() const;
  Number number() const;
  INFINITY infinity() const;
  Choices::Choice choice() const;
};


class LowerTypeBound  : public ParseTreeNode
{

public:
  LowerTypeBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerTypeBound(const LowerTypeBound& orig);
  ~LowerTypeBound();
  void operator=(const LowerTypeBound& orig);
  ITEXACCESS_DEREF(LowerTypeBound)

  SignedNumber signedNumber() const;
  Number number() const;
  MinusINFINITY minusINFINITY() const;
  Choices::Choice choice() const;
};


class ComponentNumber  : public ParseTreeNode
{

public:
  ComponentNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentNumber(const ComponentNumber& orig);
  ~ComponentNumber();
  void operator=(const ComponentNumber& orig);
  ITEXACCESS_DEREF(ComponentNumber)

  Expression expression() const;
};


class DefaultRef  : public ParseTreeNode
{

public:
  DefaultRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultRef(const DefaultRef& orig);
  ~DefaultRef();
  void operator=(const DefaultRef& orig);
  ITEXACCESS_DEREF(DefaultRef)

  DefaultGroupReference defaultGroupReference() const;
};


class ASN1_PDU_Constraint  : public TableNode
{

public:
  ASN1_PDU_Constraint( NodeInfo nodeinfo);
  ASN1_PDU_Constraint(const ASN1_PDU_Constraint& orig);
  ~ASN1_PDU_Constraint();
  void operator=(const ASN1_PDU_Constraint& orig);
  ITEXACCESS_DEREF(ASN1_PDU_Constraint)

  ConsId consId() const;
  PDU_Id pdu_Id() const;
  DerivPath derivPath() const;
  EncRuleId encRuleId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_ConsValue asn1_ConsValue() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_pdu_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_encRuleId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_ConsValue() const;
  Boolean is_present_detailedComment() const;
};


class TTCN_ASP_TypeDefs  : public StaticList
{

public:
  TTCN_ASP_TypeDefs( NodeInfo nodeinfo);
  TTCN_ASP_TypeDefs(const TTCN_ASP_TypeDefs& orig);
  ~TTCN_ASP_TypeDefs();
  void operator=(const TTCN_ASP_TypeDefs& orig);
  ITEXACCESS_DEREF(TTCN_ASP_TypeDefs)

  TTCN_ASP_TypeDef ttcn_ASP_TypeDef(int index) const;
  TTCN_ASP_TypeDef operator[](int index) const;
};


class PCO_Dcl  : public TableNode
{

public:
  PCO_Dcl( NodeInfo nodeinfo);
  PCO_Dcl(const PCO_Dcl& orig);
  ~PCO_Dcl();
  void operator=(const PCO_Dcl& orig);
  ITEXACCESS_DEREF(PCO_Dcl)

  PCO_Id pco_Id() const;
  PCO_TypeId pco_TypeId() const;
  P_Role p_Role() const;
  Comment comment() const;

  Boolean is_present_pco_Id() const;
  Boolean is_present_pco_TypeId() const;
  Boolean is_present_p_Role() const;
  Boolean is_present_comment() const;
};


class APPLICATION  : public TerminalNode
{

public:
  APPLICATION( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  APPLICATION(const APPLICATION& orig);
  ~APPLICATION();
  void operator=(const APPLICATION& orig);
  ITEXACCESS_DEREF(APPLICATION)

};


class FormalParList  : public ParseTreeList
{

public:
  FormalParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FormalParList(const FormalParList& orig);
  ~FormalParList();
  void operator=(const FormalParList& orig);
  ITEXACCESS_DEREF(FormalParList)

  FormalParAndType formalParAndType(int index) const;
  FormalParAndType operator[](int index) const;
};


class SelectionValue  : public ParseTreeNode
{

public:
  SelectionValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelectionValue(const SelectionValue& orig);
  ~SelectionValue();
  void operator=(const SelectionValue& orig);
  ITEXACCESS_DEREF(SelectionValue)

  NamedValue namedValue() const;
};


class SequenceOfValue  : public ParseTreeNode
{

public:
  SequenceOfValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SequenceOfValue(const SequenceOfValue& orig);
  ~SequenceOfValue();
  void operator=(const SequenceOfValue& orig);
  ITEXACCESS_DEREF(SequenceOfValue)

  ASN1_ValueList asn1_ValueList() const;
};


class CreateTComp  : public ParseTreeNode
{

public:
  CreateTComp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CreateTComp(const CreateTComp& orig);
  ~CreateTComp();
  void operator=(const CreateTComp& orig);
  ITEXACCESS_DEREF(CreateTComp)

  Identifier tcompIdentifier() const;
  CreateAttach createAttach() const;
};


class ASP_ParDcl  : public RowNode
{

public:
  ASP_ParDcl( NodeInfo nodeinfo,  Table* tab,  Row* row);
  ASP_ParDcl(const ASP_ParDcl& orig);
  ~ASP_ParDcl();
  void operator=(const ASP_ParDcl& orig);
  ITEXACCESS_DEREF(ASP_ParDcl)

  ASP_ParId asp_ParId() const;
  ASP_ParType asp_ParType() const;
  Comment comment() const;

  Boolean is_present_asp_ParId() const;
  Boolean is_present_asp_ParType() const;
  Boolean is_present_comment() const;
};


class Duration  : public ParseTreeNode
{

public:
  Duration( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Duration(const Duration& orig);
  ~Duration();
  void operator=(const Duration& orig);
  ITEXACCESS_DEREF(Duration)

  DeclarationValue declarationValue() const;
};


class TCompConfigDcl  : public TableNode
{

public:
  TCompConfigDcl( NodeInfo nodeinfo);
  TCompConfigDcl(const TCompConfigDcl& orig);
  ~TCompConfigDcl();
  void operator=(const TCompConfigDcl& orig);
  ITEXACCESS_DEREF(TCompConfigDcl)

  TCompConfigId tcompConfigId() const;
  Comment comment() const;
  TCompConfigInfoList tcompConfigInfoList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_tcompConfigId() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class TS_VarDcls  : public TableNode
{

public:
  TS_VarDcls( NodeInfo nodeinfo);
  TS_VarDcls(const TS_VarDcls& orig);
  ~TS_VarDcls();
  void operator=(const TS_VarDcls& orig);
  ITEXACCESS_DEREF(TS_VarDcls)

  TS_VarDclList ts_VarDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class OctetStringType  : public TerminalNode
{

public:
  OctetStringType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OctetStringType(const OctetStringType& orig);
  ~OctetStringType();
  void operator=(const OctetStringType& orig);
  ITEXACCESS_DEREF(OctetStringType)

};


class ASN1_PDU_TypeDefByRef  : public TableNode
{

public:
  ASN1_PDU_TypeDefByRef( NodeInfo nodeinfo);
  ASN1_PDU_TypeDefByRef(const ASN1_PDU_TypeDefByRef& orig);
  ~ASN1_PDU_TypeDefByRef();
  void operator=(const ASN1_PDU_TypeDefByRef& orig);
  ITEXACCESS_DEREF(ASN1_PDU_TypeDefByRef)

  PDU_Id pdu_Id() const;
  PCO_Type pco_Type() const;
  ASN1_TypeReference asn1_TypeReference() const;
  ASN1_ModuleId asn1_ModuleId() const;
  PDU_EncodingId pdu_EncodingId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;

  Boolean is_present_pdu_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_asn1_TypeReference() const;
  Boolean is_present_asn1_ModuleId() const;
  Boolean is_present_pdu_EncodingId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
};


class TS_OpResult  : public ParseTreeNode
{

public:
  TS_OpResult( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_OpResult(const TS_OpResult& orig);
  ~TS_OpResult();
  void operator=(const TS_OpResult& orig);
  ITEXACCESS_DEREF(TS_OpResult)

  TTCN_Type ttcn_Type() const;
};


class InvalidFieldEncodingCall  : public ParseTreeNode
{

public:
  InvalidFieldEncodingCall( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  InvalidFieldEncodingCall(const InvalidFieldEncodingCall& orig);
  ~InvalidFieldEncodingCall();
  void operator=(const InvalidFieldEncodingCall& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingCall)

  Identifier invalidFieldEncodingIdentifier() const;
  ActualParList actualParList() const;
};


class ASP_Constraints  : public StaticNode
{

public:
  ASP_Constraints( NodeInfo nodeinfo);
  ASP_Constraints(const ASP_Constraints& orig);
  ~ASP_Constraints();
  void operator=(const ASP_Constraints& orig);
  ITEXACCESS_DEREF(ASP_Constraints)

  TTCN_ASP_Constraints ttcn_ASP_Constraints() const;
  ASN1_ASP_Constraints asn1_ASP_Constraints() const;
};


class EncRuleId  : public ParseTreeNode
{

public:
  EncRuleId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncRuleId(const EncRuleId& orig);
  ~EncRuleId();
  void operator=(const EncRuleId& orig);
  ITEXACCESS_DEREF(EncRuleId)

  Identifier encodingRuleIdentifier() const;
};


class InvalidFieldEncodingDef  : public TableNode
{

public:
  InvalidFieldEncodingDef( NodeInfo nodeinfo);
  InvalidFieldEncodingDef(const InvalidFieldEncodingDef& orig);
  ~InvalidFieldEncodingDef();
  void operator=(const InvalidFieldEncodingDef& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingDef)

  InvalidFieldEncodingId invalidFieldEncodingId() const;
  Encoding_TypeList encoding_TypeList() const;
  Comment comment() const;
  InvalidFieldEncodingDefinition invalidFieldEncodingDefinition() const;
  DetailedComment detailedComment() const;

  Boolean is_present_invalidFieldEncodingId() const;
  Boolean is_present_encoding_TypeList() const;
  Boolean is_present_comment() const;
  Boolean is_present_invalidFieldEncodingDefinition() const;
  Boolean is_present_detailedComment() const;
};


class Imports  : public TableNode
{

public:
  Imports( NodeInfo nodeinfo);
  Imports(const Imports& orig);
  ~Imports();
  void operator=(const Imports& orig);
  ITEXACCESS_DEREF(Imports)

  SourceName sourceName() const;
  SourceRef sourceRef() const;
  Objective objective() const;
  Comment comment() const;
  ImportedObjectList importedObjectList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_sourceName() const;
  Boolean is_present_sourceRef() const;
  Boolean is_present_objective() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class TeletexString  : public TerminalNode
{

public:
  TeletexString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TeletexString(const TeletexString& orig);
  ~TeletexString();
  void operator=(const TeletexString& orig);
  ITEXACCESS_DEREF(TeletexString)

};


class Create  : public ParseTreeNode
{

public:
  Create( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Create(const Create& orig);
  ~Create();
  void operator=(const Create& orig);
  ITEXACCESS_DEREF(Create)

  CreateList createList() const;
};


class TestCaseId  : public ParseTreeNode
{

public:
  TestCaseId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestCaseId(const TestCaseId& orig);
  ~TestCaseId();
  void operator=(const TestCaseId& orig);
  ITEXACCESS_DEREF(TestCaseId)

  Identifier testCaseIdentifier() const;
};


class ASN1_ASP_TypeDefByRefList  : public StaticList
{

public:
  ASN1_ASP_TypeDefByRefList( NodeInfo nodeinfo);
  ASN1_ASP_TypeDefByRefList(const ASN1_ASP_TypeDefByRefList& orig);
  ~ASN1_ASP_TypeDefByRefList();
  void operator=(const ASN1_ASP_TypeDefByRefList& orig);
  ITEXACCESS_DEREF(ASN1_ASP_TypeDefByRefList)

  ASN1_ASP_TypeDefByRef asn1_ASP_TypeDefByRef(int index) const;
  ASN1_ASP_TypeDefByRef operator[](int index) const;
};


class TCompId  : public ParseTreeNode
{

public:
  TCompId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TCompId(const TCompId& orig);
  ~TCompId();
  void operator=(const TCompId& orig);
  ITEXACCESS_DEREF(TCompId)

  Identifier tcompIdentifier() const;
};


class PTC  : public TerminalNode
{

public:
  PTC( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PTC(const PTC& orig);
  ~PTC();
  void operator=(const PTC& orig);
  ITEXACCESS_DEREF(PTC)

};


class PRESENT  : public TerminalNode
{

public:
  PRESENT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PRESENT(const PRESENT& orig);
  ~PRESENT();
  void operator=(const PRESENT& orig);
  ITEXACCESS_DEREF(PRESENT)

};


class DefaultValue  : public ParseTreeNode
{

public:
  DefaultValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultValue(const DefaultValue& orig);
  ~DefaultValue();
  void operator=(const DefaultValue& orig);
  ITEXACCESS_DEREF(DefaultValue)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class Exponent  : public ParseTreeNode
{

public:
  Exponent( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Exponent(const Exponent& orig);
  ~Exponent();
  void operator=(const Exponent& orig);
  ITEXACCESS_DEREF(Exponent)

  SignedNumber signedNumber() const;
  Number number() const;
  Choices::Choice choice() const;
};


class ValueRange  : public ParseTreeNode
{

public:
  ValueRange( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueRange(const ValueRange& orig);
  ~ValueRange();
  void operator=(const ValueRange& orig);
  ITEXACCESS_DEREF(ValueRange)

  LowerEndpoint lowerEndpoint() const;
  UpperEndpoint upperEndpoint() const;
};


class IdOrNum  : public ParseTreeNode
{

public:
  IdOrNum( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IdOrNum(const IdOrNum& orig);
  ~IdOrNum();
  void operator=(const IdOrNum& orig);
  ITEXACCESS_DEREF(IdOrNum)

  DataObjectReference dataObjectReference() const;
  Number number() const;
  SignedNumber signedNumber() const;
  Choices::Choice choice() const;
};


class DeclarationsPart  : public StaticNode
{

public:
  DeclarationsPart( NodeInfo nodeinfo);
  DeclarationsPart(const DeclarationsPart& orig);
  ~DeclarationsPart();
  void operator=(const DeclarationsPart& orig);
  ITEXACCESS_DEREF(DeclarationsPart)

  Definitions definitions() const;
  ParamAndSelection paramAndSelection() const;
  Declarations declarations() const;
  ComplexDefinitions complexDefinitions() const;
};


class ReferenceType  : public ParseTreeNode
{

public:
  ReferenceType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ReferenceType(const ReferenceType& orig);
  ~ReferenceType();
  void operator=(const ReferenceType& orig);
  ITEXACCESS_DEREF(ReferenceType)

  Identifier identifier() const;
};


class EncodingVariationSet  : public TableNode
{

public:
  EncodingVariationSet( NodeInfo nodeinfo);
  EncodingVariationSet(const EncodingVariationSet& orig);
  ~EncodingVariationSet();
  void operator=(const EncodingVariationSet& orig);
  ITEXACCESS_DEREF(EncodingVariationSet)

  EncodingRuleId encodingRuleId() const;
  Encoding_TypeList encoding_TypeList() const;
  Comment comment() const;
  EncodingVariationList encodingVariationList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_encodingRuleId() const;
  Boolean is_present_encoding_TypeList() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class Plus  : public TerminalNode
{

public:
  Plus( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Plus(const Plus& orig);
  ~Plus();
  void operator=(const Plus& orig);
  ITEXACCESS_DEREF(Plus)

};


class TestStepGroupReference  : public TerminalNode
{

public:
  TestStepGroupReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepGroupReference(const TestStepGroupReference& orig);
  ~TestStepGroupReference();
  void operator=(const TestStepGroupReference& orig);
  ITEXACCESS_DEREF(TestStepGroupReference)

};


class InnerTypeConstraints  : public ParseTreeNode
{

public:
  InnerTypeConstraints( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  InnerTypeConstraints(const InnerTypeConstraints& orig);
  ~InnerTypeConstraints();
  void operator=(const InnerTypeConstraints& orig);
  ITEXACCESS_DEREF(InnerTypeConstraints)

  WithComponent withComponent() const;
  WithComponents withComponents() const;
  Choices::Choice choice() const;
};


class Omit  : public ParseTreeNode
{

public:
  Omit( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Omit(const Omit& orig);
  ~Omit();
  void operator=(const Omit& orig);
  ITEXACCESS_DEREF(Omit)

  OMIT omit() const;
};


class ConstraintExpression  : public ParseTreeNode
{

public:
  ConstraintExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConstraintExpression(const ConstraintExpression& orig);
  ~ConstraintExpression();
  void operator=(const ConstraintExpression& orig);
  ITEXACCESS_DEREF(ConstraintExpression)

  Expression expression() const;
};


class ConsRef  : public ParseTreeNode
{

public:
  ConsRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConsRef(const ConsRef& orig);
  ~ConsRef();
  void operator=(const ConsRef& orig);
  ITEXACCESS_DEREF(ConsRef)

  Identifier constraintIdentifier() const;
  ActualCrefParList actualCrefParList() const;
};


class CompactTestGroup  : public TableNode
{

public:
  CompactTestGroup( NodeInfo nodeinfo);
  CompactTestGroup(const CompactTestGroup& orig);
  ~CompactTestGroup();
  void operator=(const CompactTestGroup& orig);
  ITEXACCESS_DEREF(CompactTestGroup)

  TestGroupId testGroupId() const;
  DefaultsRef defaultsRef() const;
  SelExprId selExprId() const;
  Objective objective() const;
  CompactTestCaseList compactTestCaseList() const;

  Boolean is_present_testGroupId() const;
  Boolean is_present_defaultsRef() const;
  Boolean is_present_selExprId() const;
  Boolean is_present_objective() const;
};


class EncodingDefList  : public StaticList
{

public:
  EncodingDefList( NodeInfo nodeinfo);
  EncodingDefList(const EncodingDefList& orig);
  ~EncodingDefList();
  void operator=(const EncodingDefList& orig);
  ITEXACCESS_DEREF(EncodingDefList)

  EncodingDefinition encodingDefinition(int index) const;
  EncodingDefinition operator[](int index) const;
};


class TS_ParDcl  : public TableNode
{

public:
  TS_ParDcl( NodeInfo nodeinfo);
  TS_ParDcl(const TS_ParDcl& orig);
  ~TS_ParDcl();
  void operator=(const TS_ParDcl& orig);
  ITEXACCESS_DEREF(TS_ParDcl)

  TS_ParId ts_ParId() const;
  TS_ParType ts_ParType() const;
  PICS_PIXITref pics_PIXITref() const;
  Comment comment() const;

  Boolean is_present_ts_ParId() const;
  Boolean is_present_ts_ParType() const;
  Boolean is_present_pics_PIXITref() const;
  Boolean is_present_comment() const;
};


class AnyValue  : public ParseTreeNode
{

public:
  AnyValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AnyValue(const AnyValue& orig);
  ~AnyValue();
  void operator=(const AnyValue& orig);
  ITEXACCESS_DEREF(AnyValue)

  ReferenceType referenceType() const;
  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class DefinedType  : public ParseTreeNode
{

public:
  DefinedType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefinedType(const DefinedType& orig);
  ~DefinedType();
  void operator=(const DefinedType& orig);
  ITEXACCESS_DEREF(DefinedType)

  Identifier identifier() const;
};


class TTCN_PDU_Constraint  : public TableNode
{

public:
  TTCN_PDU_Constraint( NodeInfo nodeinfo);
  TTCN_PDU_Constraint(const TTCN_PDU_Constraint& orig);
  ~TTCN_PDU_Constraint();
  void operator=(const TTCN_PDU_Constraint& orig);
  ITEXACCESS_DEREF(TTCN_PDU_Constraint)

  ConsId consId() const;
  PDU_Id pdu_Id() const;
  DerivPath derivPath() const;
  EncRuleId encRuleId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  PDU_FieldValues pdu_FieldValues() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_pdu_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_encRuleId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class TCompConfigInfoList  : public RowList
{

public:
  TCompConfigInfoList( NodeInfo nodeinfo,  Table* tab);
  TCompConfigInfoList(const TCompConfigInfoList& orig);
  ~TCompConfigInfoList();
  void operator=(const TCompConfigInfoList& orig);
  ITEXACCESS_DEREF(TCompConfigInfoList)

  TCompConfigInfo tcompConfigInfo(int index) const;
  TCompConfigInfo operator[](int index) const;
};


class UT  : public TerminalNode
{

public:
  UT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UT(const UT& orig);
  ~UT();
  void operator=(const UT& orig);
  ITEXACCESS_DEREF(UT)

};


class PRIVATE_  : public TerminalNode
{

public:
  PRIVATE_( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PRIVATE_(const PRIVATE_& orig);
  ~PRIVATE_();
  void operator=(const PRIVATE_& orig);
  ITEXACCESS_DEREF(PRIVATE_)

};


class Tag  : public ParseTreeNode
{

public:
  Tag( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Tag(const Tag& orig);
  ~Tag();
  void operator=(const Tag& orig);
  ITEXACCESS_DEREF(Tag)

  ClassType classType() const;
  ClassNumber classNumber() const;

  Boolean is_present_classType() const;
};


class MultExpression  : public ParseTreeNode
{

public:
  MultExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MultExpression(const MultExpression& orig);
  ~MultExpression();
  void operator=(const MultExpression& orig);
  ITEXACCESS_DEREF(MultExpression)

  Term term() const;
  MultOp multOp() const;
  Factor factor() const;
};


class UpperRangeBound  : public ParseTreeNode
{

public:
  UpperRangeBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperRangeBound(const UpperRangeBound& orig);
  ~UpperRangeBound();
  void operator=(const UpperRangeBound& orig);
  ITEXACCESS_DEREF(UpperRangeBound)

  ConstraintExpression constraintExpression() const;
  INFINITY infinity() const;
  Choices::Choice choice() const;
};


class SO_DefIndexList  : public RowList
{

public:
  SO_DefIndexList( NodeInfo nodeinfo,  Table* tab);
  SO_DefIndexList(const SO_DefIndexList& orig);
  ~SO_DefIndexList();
  void operator=(const SO_DefIndexList& orig);
  ITEXACCESS_DEREF(SO_DefIndexList)

  SO_DefIndex SO_defIndex(int index) const;
  SO_DefIndex operator[](int index) const;
};


class EncodingReference  : public TerminalNode
{

public:
  EncodingReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncodingReference(const EncodingReference& orig);
  ~EncodingReference();
  void operator=(const EncodingReference& orig);
  ITEXACCESS_DEREF(EncodingReference)

};


class BitRef  : public ParseTreeNode
{

public:
  BitRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BitRef(const BitRef& orig);
  ~BitRef();
  void operator=(const BitRef& orig);
  ITEXACCESS_DEREF(BitRef)

  BitIdentifier bitIdentifier() const;
  BitNumber bitNumber() const;
  Choices::Choice choice() const;
};


class UnaryOp  : public ParseTreeNode
{

public:
  UnaryOp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UnaryOp(const UnaryOp& orig);
  ~UnaryOp();
  void operator=(const UnaryOp& orig);
  ITEXACCESS_DEREF(UnaryOp)

  Plus plus() const;
  Minus minus() const;
  Not not1() const;
  Choices::Choice choice() const;
};


class ASP_ParIdAndFullId  : public ParseTreeNode
{

public:
  ASP_ParIdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_ParIdAndFullId(const ASP_ParIdAndFullId& orig);
  ~ASP_ParIdAndFullId();
  void operator=(const ASP_ParIdAndFullId& orig);
  ITEXACCESS_DEREF(ASP_ParIdAndFullId)

  Identifier asp_ParIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class TimerId  : public ParseTreeNode
{

public:
  TimerId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TimerId(const TimerId& orig);
  ~TimerId();
  void operator=(const TimerId& orig);
  ITEXACCESS_DEREF(TimerId)

  Identifier timerIdentifier() const;
};


class TimerDcl  : public TableNode
{

public:
  TimerDcl( NodeInfo nodeinfo);
  TimerDcl(const TimerDcl& orig);
  ~TimerDcl();
  void operator=(const TimerDcl& orig);
  ITEXACCESS_DEREF(TimerDcl)

  TimerId timerId() const;
  Duration duration() const;
  Unit unit() const;
  Comment comment() const;

  Boolean is_present_timerId() const;
  Boolean is_present_duration() const;
  Boolean is_present_unit() const;
  Boolean is_present_comment() const;
};


class P_Role  : public ParseTreeNode
{

public:
  P_Role( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  P_Role(const P_Role& orig);
  ~P_Role();
  void operator=(const P_Role& orig);
  ITEXACCESS_DEREF(P_Role)

  PCO_Role pco_Role() const;
};


class TS_ParType  : public ParseTreeNode
{

public:
  TS_ParType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ParType(const TS_ParType& orig);
  ~TS_ParType();
  void operator=(const TS_ParType& orig);
  ITEXACCESS_DEREF(TS_ParType)

  TTCN_Type ttcn_Type() const;
};


class FullIdentifier  : public TerminalNode
{

public:
  FullIdentifier( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FullIdentifier(const FullIdentifier& orig);
  ~FullIdentifier();
  void operator=(const FullIdentifier& orig);
  ITEXACCESS_DEREF(FullIdentifier)

};


class EncVariationIdAndParList  : public ParseTreeNode
{

public:
  EncVariationIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncVariationIdAndParList(const EncVariationIdAndParList& orig);
  ~EncVariationIdAndParList();
  void operator=(const EncVariationIdAndParList& orig);
  ITEXACCESS_DEREF(EncVariationIdAndParList)

  Identifier encVariationIdentifier() const;
  FormalParList formalParList() const;
};


class ObjectDescriptor  : public TerminalNode
{

public:
  ObjectDescriptor( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjectDescriptor(const ObjectDescriptor& orig);
  ~ObjectDescriptor();
  void operator=(const ObjectDescriptor& orig);
  ITEXACCESS_DEREF(ObjectDescriptor)

};


class T61String  : public TerminalNode
{

public:
  T61String( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  T61String(const T61String& orig);
  ~T61String();
  void operator=(const T61String& orig);
  ITEXACCESS_DEREF(T61String)

};


class ObjectIdentifierValue  : public ParseTreeNode
{

public:
  ObjectIdentifierValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ObjectIdentifierValue(const ObjectIdentifierValue& orig);
  ~ObjectIdentifierValue();
  void operator=(const ObjectIdentifierValue& orig);
  ITEXACCESS_DEREF(ObjectIdentifierValue)

  ObjIdComponentList objIdComponentList() const;
};


class LowerValueBound  : public ParseTreeNode
{

public:
  LowerValueBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerValueBound(const LowerValueBound& orig);
  ~LowerValueBound();
  void operator=(const LowerValueBound& orig);
  ITEXACCESS_DEREF(LowerValueBound)

  ValueBound valueBound() const;
};


class PCO_TypeId  : public ParseTreeNode
{

public:
  PCO_TypeId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCO_TypeId(const PCO_TypeId& orig);
  ~PCO_TypeId();
  void operator=(const PCO_TypeId& orig);
  ITEXACCESS_DEREF(PCO_TypeId)

  Identifier pco_TypeIdentifier() const;
};


class TestCaseIndex  : public TableNode
{

public:
  TestCaseIndex( NodeInfo nodeinfo);
  TestCaseIndex(const TestCaseIndex& orig);
  ~TestCaseIndex();
  void operator=(const TestCaseIndex& orig);
  ITEXACCESS_DEREF(TestCaseIndex)

  SO_CaseIndexList SO_caseIndexList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class Constraint  : public ParseTreeNode
{

public:
  Constraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Constraint(const Constraint& orig);
  ~Constraint();
  void operator=(const Constraint& orig);
  ITEXACCESS_DEREF(Constraint)

  ValueConstraint valueConstraint() const;
  PresenceConstraint presenceConstraint() const;

  Boolean is_present_valueConstraint() const;
  Boolean is_present_presenceConstraint() const;
};


class SizeConstraint  : public ParseTreeNode
{

public:
  SizeConstraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SizeConstraint(const SizeConstraint& orig);
  ~SizeConstraint();
  void operator=(const SizeConstraint& orig);
  ITEXACCESS_DEREF(SizeConstraint)

  SubTypeSpec subTypeSpec() const;
};


class ASN1_ASP_Constraint  : public TableNode
{

public:
  ASN1_ASP_Constraint( NodeInfo nodeinfo);
  ASN1_ASP_Constraint(const ASN1_ASP_Constraint& orig);
  ~ASN1_ASP_Constraint();
  void operator=(const ASN1_ASP_Constraint& orig);
  ITEXACCESS_DEREF(ASN1_ASP_Constraint)

  ConsId consId() const;
  ASP_Id asp_Id() const;
  DerivPath derivPath() const;
  Comment comment() const;
  ASN1_ConsValue asn1_ConsValue() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_asp_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_ConsValue() const;
  Boolean is_present_detailedComment() const;
};


class ASP_Id  : public ParseTreeNode
{

public:
  ASP_Id( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_Id(const ASP_Id& orig);
  ~ASP_Id();
  void operator=(const ASP_Id& orig);
  ITEXACCESS_DEREF(ASP_Id)

  ASP_IdAndFullId asp_IdAndFullId() const;
};


class SimpleTypeDefinition  : public ParseTreeNode
{

public:
  SimpleTypeDefinition( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SimpleTypeDefinition(const SimpleTypeDefinition& orig);
  ~SimpleTypeDefinition();
  void operator=(const SimpleTypeDefinition& orig);
  ITEXACCESS_DEREF(SimpleTypeDefinition)

  TypeAndRestriction typeAndRestriction() const;
};


class IntegerType  : public ParseTreeNode
{

public:
  IntegerType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IntegerType(const IntegerType& orig);
  ~IntegerType();
  void operator=(const IntegerType& orig);
  ITEXACCESS_DEREF(IntegerType)

  NamedNumberList namedNumberList() const;
};


class ArrayRefOrComp  : public ParseTreeNode
{

public:
  ArrayRefOrComp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ArrayRefOrComp(const ArrayRefOrComp& orig);
  ~ArrayRefOrComp();
  void operator=(const ArrayRefOrComp& orig);
  ITEXACCESS_DEREF(ArrayRefOrComp)

  ComponentIdentifier componentIdentifier() const;
  BitRef bitRef() const;
  ComponentPosition componentPosition() const;
  Choices::Choice choice() const;
};


class CM_TypeDefs  : public StaticNode
{

public:
  CM_TypeDefs( NodeInfo nodeinfo);
  CM_TypeDefs(const CM_TypeDefs& orig);
  ~CM_TypeDefs();
  void operator=(const CM_TypeDefs& orig);
  ITEXACCESS_DEREF(CM_TypeDefs)

  TTCN_CM_TypeDefs ttcn_CM_TypeDefs() const;
  ASN1_CM_TypeDefs asn1_CM_TypeDefs() const;
};


class NameAndNumberForm  : public ParseTreeNode
{

public:
  NameAndNumberForm( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NameAndNumberForm(const NameAndNumberForm& orig);
  ~NameAndNumberForm();
  void operator=(const NameAndNumberForm& orig);
  ITEXACCESS_DEREF(NameAndNumberForm)

  NameForm nameForm() const;
  NumberForm numberForm() const;
};


class SetOfType  : public ParseTreeNode
{

public:
  SetOfType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SetOfType(const SetOfType& orig);
  ~SetOfType();
  void operator=(const SetOfType& orig);
  ITEXACCESS_DEREF(SetOfType)

  ASN1_Type asn1_Type() const;

  Boolean is_present_asn1_Type() const;
};


class Factor  : public ParseTreeNode
{

public:
  Factor( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Factor(const Factor& orig);
  ~Factor();
  void operator=(const Factor& orig);
  ITEXACCESS_DEREF(Factor)

  UnaryExpression unaryExpression() const;
  Primary primary() const;
  Choices::Choice choice() const;
};


class TestStepId  : public ParseTreeNode
{

public:
  TestStepId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepId(const TestStepId& orig);
  ~TestStepId();
  void operator=(const TestStepId& orig);
  ITEXACCESS_DEREF(TestStepId)

  TestStepIdAndParList testStepIdAndParList() const;
};


class BehaviourLine  : public RowNode
{

public:
  BehaviourLine( NodeInfo nodeinfo,  Table* tab,  Row* row);
  BehaviourLine(const BehaviourLine& orig);
  ~BehaviourLine();
  void operator=(const BehaviourLine& orig);
  ITEXACCESS_DEREF(BehaviourLine)

  LineNumber lineNumber() const;
  LabelId labelId() const;
  Line line() const;
  Cref cref() const;
  VerdictId verdictId() const;
  Comment comment() const;
  Children children() const;

  Boolean is_present_lineNumber() const;
  Boolean is_present_labelId() const;
  Boolean is_present_line() const;
  Boolean is_present_cref() const;
  Boolean is_present_verdictId() const;
  Boolean is_present_comment() const;
};


class Children  : public RowList
{

public:
  Children( NodeInfo nodeinfo,  Table* tab,  Row* row);
  Children(const Children& orig);
  ~Children();
  void operator=(const Children& orig);
  ITEXACCESS_DEREF(Children)

  BehaviourLine behaviourLine(int index) const;
  BehaviourLine operator[](int index) const;
};


class Objective  : public TerminalNode
{

public:
  Objective( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Objective(const Objective& orig);
  ~Objective();
  void operator=(const Objective& orig);
  ITEXACCESS_DEREF(Objective)

};


class ValueList  : public ParseTreeList
{

public:
  ValueList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueList(const ValueList& orig);
  ~ValueList();
  void operator=(const ValueList& orig);
  ITEXACCESS_DEREF(ValueList)

  ConstraintValueAndAttributes constraintValueAndAttributes(int index) const;
  ConstraintValueAndAttributes operator[](int index) const;
};


class CP_DclList  : public StaticList
{

public:
  CP_DclList( NodeInfo nodeinfo);
  CP_DclList(const CP_DclList& orig);
  ~CP_DclList();
  void operator=(const CP_DclList& orig);
  ITEXACCESS_DEREF(CP_DclList)

  CP_Dcl cp_Dcl(int index) const;
  CP_Dcl operator[](int index) const;
};


class SuiteOverviewPart  : public StaticNode
{

public:
  SuiteOverviewPart( NodeInfo nodeinfo);
  SuiteOverviewPart(const SuiteOverviewPart& orig);
  ~SuiteOverviewPart();
  void operator=(const SuiteOverviewPart& orig);
  ITEXACCESS_DEREF(SuiteOverviewPart)

  SuiteStructure suiteStructure() const;
  TestCaseIndex testCaseIndex() const;
  TestStepIndex testStepIndex() const;
  DefaultIndex defaultIndex() const;
};


class ANYValue  : public TerminalNode
{

public:
  ANYValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ANYValue(const ANYValue& orig);
  ~ANYValue();
  void operator=(const ANYValue& orig);
  ITEXACCESS_DEREF(ANYValue)

};


class MultOp  : public ParseTreeNode
{

public:
  MultOp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MultOp(const MultOp& orig);
  ~MultOp();
  void operator=(const MultOp& orig);
  ITEXACCESS_DEREF(MultOp)

  Mult mult() const;
  Div div() const;
  Mod mod() const;
  And and1() const;
  Choices::Choice choice() const;
};


class ASN1_PDU_TypeDef  : public TableNode
{

public:
  ASN1_PDU_TypeDef( NodeInfo nodeinfo);
  ASN1_PDU_TypeDef(const ASN1_PDU_TypeDef& orig);
  ~ASN1_PDU_TypeDef();
  void operator=(const ASN1_PDU_TypeDef& orig);
  ITEXACCESS_DEREF(ASN1_PDU_TypeDef)

  PDU_Id pdu_Id() const;
  PCO_Type pco_Type() const;
  PDU_EncodingId pdu_EncodingId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;
  DetailedComment detailedComment() const;

  Boolean is_present_pdu_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_pdu_EncodingId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
  Boolean is_present_detailedComment() const;
};


class VariationDefault  : public ParseTreeNode
{

public:
  VariationDefault( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VariationDefault(const VariationDefault& orig);
  ~VariationDefault();
  void operator=(const VariationDefault& orig);
  ITEXACCESS_DEREF(VariationDefault)

  Expression expression() const;
};


class IF_PRESENT  : public TerminalNode
{

public:
  IF_PRESENT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IF_PRESENT(const IF_PRESENT& orig);
  ~IF_PRESENT();
  void operator=(const IF_PRESENT& orig);
  ITEXACCESS_DEREF(IF_PRESENT)

};


class ASN1_ASP_Constraints  : public StaticList
{

public:
  ASN1_ASP_Constraints( NodeInfo nodeinfo);
  ASN1_ASP_Constraints(const ASN1_ASP_Constraints& orig);
  ~ASN1_ASP_Constraints();
  void operator=(const ASN1_ASP_Constraints& orig);
  ITEXACCESS_DEREF(ASN1_ASP_Constraints)

  ASN1_ASP_Constraint asn1_ASP_Constraint(int index) const;
  ASN1_ASP_Constraint operator[](int index) const;
};


class CM_ParIdOrMacro  : public ParseTreeNode
{

public:
  CM_ParIdOrMacro( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CM_ParIdOrMacro(const CM_ParIdOrMacro& orig);
  ~CM_ParIdOrMacro();
  void operator=(const CM_ParIdOrMacro& orig);
  ITEXACCESS_DEREF(CM_ParIdOrMacro)

  CM_ParIdAndFullId cm_ParIdAndFullId() const;
  MacroSymbol macroSymbol() const;
  Choices::Choice choice() const;
};


class Or  : public TerminalNode
{

public:
  Or( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Or(const Or& orig);
  ~Or();
  void operator=(const Or& orig);
  ITEXACCESS_DEREF(Or)

};


class DefaultCase  : public TableNode
{

public:
  DefaultCase( NodeInfo nodeinfo);
  DefaultCase(const DefaultCase& orig);
  ~DefaultCase();
  void operator=(const DefaultCase& orig);
  ITEXACCESS_DEREF(DefaultCase)

  DefaultId defaultId() const;
  DefaultRef defaultRef() const;
  Objective objective() const;
  Comment comment() const;
  Description description() const;
  BehaviourDescription behaviourDescription() const;
  DetailedComment detailedComment() const;

  Boolean is_present_defaultId() const;
  Boolean is_present_defaultRef() const;
  Boolean is_present_objective() const;
  Boolean is_present_comment() const;
  Boolean is_present_description() const;
  Boolean is_present_detailedComment() const;
};


class TestStepGroup  : public TableNode
{

public:
  TestStepGroup( NodeInfo nodeinfo);
  TestStepGroup(const TestStepGroup& orig);
  ~TestStepGroup();
  void operator=(const TestStepGroup& orig);
  ITEXACCESS_DEREF(TestStepGroup)

  TestStepGroupId testStepGroupId() const;
  TestStepGroupOrTestStepList testStepGroupOrTestStepList() const;

  Boolean is_present_testStepGroupId() const;
};


class StructTypeConstraints  : public StaticList
{

public:
  StructTypeConstraints( NodeInfo nodeinfo);
  StructTypeConstraints(const StructTypeConstraints& orig);
  ~StructTypeConstraints();
  void operator=(const StructTypeConstraints& orig);
  ITEXACCESS_DEREF(StructTypeConstraints)

  StructTypeConstraint structTypeConstraint(int index) const;
  StructTypeConstraint operator[](int index) const;
};


class CP_Id  : public ParseTreeNode
{

public:
  CP_Id( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CP_Id(const CP_Id& orig);
  ~CP_Id();
  void operator=(const CP_Id& orig);
  ITEXACCESS_DEREF(CP_Id)

  Identifier cp_Identifier() const;
};


class ASN1_TypeRefList  : public StaticList
{

public:
  ASN1_TypeRefList( NodeInfo nodeinfo);
  ASN1_TypeRefList(const ASN1_TypeRefList& orig);
  ~ASN1_TypeRefList();
  void operator=(const ASN1_TypeRefList& orig);
  ITEXACCESS_DEREF(ASN1_TypeRefList)

  ASN1_TypeRef asn1_TypeRef(int index) const;
  ASN1_TypeRef operator[](int index) const;
};


class StructTypeDef  : public TableNode
{

public:
  StructTypeDef( NodeInfo nodeinfo);
  StructTypeDef(const StructTypeDef& orig);
  ~StructTypeDef();
  void operator=(const StructTypeDef& orig);
  ITEXACCESS_DEREF(StructTypeDef)

  StructId structId() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ElemDcls elemDcls() const;
  DetailedComment detailedComment() const;

  Boolean is_present_structId() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class TestGroupReference  : public TerminalNode
{

public:
  TestGroupReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestGroupReference(const TestGroupReference& orig);
  ~TestGroupReference();
  void operator=(const TestGroupReference& orig);
  ITEXACCESS_DEREF(TestGroupReference)

};


class Base  : public ParseTreeNode
{

public:
  Base( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Base(const Base& orig);
  ~Base();
  void operator=(const Base& orig);
  ITEXACCESS_DEREF(Base)

  Two two() const;
  Ten ten() const;
  Choices::Choice choice() const;
};


class NameForm  : public ParseTreeNode
{

public:
  NameForm( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NameForm(const NameForm& orig);
  ~NameForm();
  void operator=(const NameForm& orig);
  ITEXACCESS_DEREF(NameForm)

  Identifier identifier() const;
};


class TTCN_ASP_Constraint  : public TableNode
{

public:
  TTCN_ASP_Constraint( NodeInfo nodeinfo);
  TTCN_ASP_Constraint(const TTCN_ASP_Constraint& orig);
  ~TTCN_ASP_Constraint();
  void operator=(const TTCN_ASP_Constraint& orig);
  ITEXACCESS_DEREF(TTCN_ASP_Constraint)

  ConsId consId() const;
  ASP_Id asp_Id() const;
  DerivPath derivPath() const;
  Comment comment() const;
  ASP_ParValues asp_ParValues() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_asp_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class FormalParIdList  : public ParseTreeList
{

public:
  FormalParIdList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FormalParIdList(const FormalParIdList& orig);
  ~FormalParIdList();
  void operator=(const FormalParIdList& orig);
  ITEXACCESS_DEREF(FormalParIdList)

  Identifier formalParIdentifier(int index) const;
  Identifier operator[](int index) const;
};


class NamedNumberList  : public ParseTreeList
{

public:
  NamedNumberList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedNumberList(const NamedNumberList& orig);
  ~NamedNumberList();
  void operator=(const NamedNumberList& orig);
  ITEXACCESS_DEREF(NamedNumberList)

  NamedNumber namedNumber(int index) const;
  NamedNumber operator[](int index) const;
};


class PDU_FieldDcl  : public RowNode
{

public:
  PDU_FieldDcl( NodeInfo nodeinfo,  Table* tab,  Row* row);
  PDU_FieldDcl(const PDU_FieldDcl& orig);
  ~PDU_FieldDcl();
  void operator=(const PDU_FieldDcl& orig);
  ITEXACCESS_DEREF(PDU_FieldDcl)

  PDU_FieldId pdu_FieldId() const;
  PDU_FieldType pdu_FieldType() const;
  PDU_FieldEncoding pdu_FieldEncoding() const;
  Comment comment() const;

  Boolean is_present_pdu_FieldId() const;
  Boolean is_present_pdu_FieldType() const;
  Boolean is_present_pdu_FieldEncoding() const;
  Boolean is_present_comment() const;
};


class EncodingRuleId  : public ParseTreeNode
{

public:
  EncodingRuleId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncodingRuleId(const EncodingRuleId& orig);
  ~EncodingRuleId();
  void operator=(const EncodingRuleId& orig);
  ITEXACCESS_DEREF(EncodingRuleId)

  Identifier encodingRuleIdentifier() const;
};


class ElemDcl  : public RowNode
{

public:
  ElemDcl( NodeInfo nodeinfo,  Table* tab,  Row* row);
  ElemDcl(const ElemDcl& orig);
  ~ElemDcl();
  void operator=(const ElemDcl& orig);
  ITEXACCESS_DEREF(ElemDcl)

  ElemId elemId() const;
  ElemType elemType() const;
  PDU_FieldEncoding pdu_FieldEncoding() const;
  Comment comment() const;

  Boolean is_present_elemId() const;
  Boolean is_present_elemType() const;
  Boolean is_present_pdu_FieldEncoding() const;
  Boolean is_present_comment() const;
};


class LocalTree  : public RowNode
{

public:
  LocalTree( NodeInfo nodeinfo,  Table* tab,  Row* row);
  LocalTree(const LocalTree& orig);
  ~LocalTree();
  void operator=(const LocalTree& orig);
  ITEXACCESS_DEREF(LocalTree)

  Header header() const;
  BehaviourLineList behaviourLineList() const;

  Boolean is_present_header() const;
};


class ReferenceList  : public ParseTreeNode
{

public:
  ReferenceList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ReferenceList(const ReferenceList& orig);
  ~ReferenceList();
  void operator=(const ReferenceList& orig);
  ITEXACCESS_DEREF(ReferenceList)

  ArrayRefOrComp arrayRefOrComp() const;
  ComponentReferenceList componentReferenceList() const;
};


class TimeUnit  : public ParseTreeNode
{

public:
  TimeUnit( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TimeUnit(const TimeUnit& orig);
  ~TimeUnit();
  void operator=(const TimeUnit& orig);
  ITEXACCESS_DEREF(TimeUnit)

  PicoSeconds picoSeconds() const;
  NanoSeconds nanoSeconds() const;
  MicroSeconds microSeconds() const;
  MilliSeconds milliSeconds() const;
  Seconds seconds() const;
  Minutes minutes() const;
  Choices::Choice choice() const;
};


class NotEqual  : public TerminalNode
{

public:
  NotEqual( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NotEqual(const NotEqual& orig);
  ~NotEqual();
  void operator=(const NotEqual& orig);
  ITEXACCESS_DEREF(NotEqual)

};


class NamedConstraint  : public ParseTreeNode
{

public:
  NamedConstraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedConstraint(const NamedConstraint& orig);
  ~NamedConstraint();
  void operator=(const NamedConstraint& orig);
  ITEXACCESS_DEREF(NamedConstraint)

  Identifier identifier() const;
  Constraint constraint() const;
};


class NamedNumber  : public ParseTreeNode
{

public:
  NamedNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedNumber(const NamedNumber& orig);
  ~NamedNumber();
  void operator=(const NamedNumber& orig);
  ITEXACCESS_DEREF(NamedNumber)

  Identifier identifier() const;
  IdOrNum idOrNum() const;
};


class PDU_FieldIdOrMacro  : public ParseTreeNode
{

public:
  PDU_FieldIdOrMacro( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldIdOrMacro(const PDU_FieldIdOrMacro& orig);
  ~PDU_FieldIdOrMacro();
  void operator=(const PDU_FieldIdOrMacro& orig);
  ITEXACCESS_DEREF(PDU_FieldIdOrMacro)

  PDU_FieldIdAndFullId pdu_FieldIdAndFullId() const;
  MacroSymbol macroSymbol() const;
  Choices::Choice choice() const;
};


class SimpleTypeDefs  : public TableNode
{

public:
  SimpleTypeDefs( NodeInfo nodeinfo);
  SimpleTypeDefs(const SimpleTypeDefs& orig);
  ~SimpleTypeDefs();
  void operator=(const SimpleTypeDefs& orig);
  ITEXACCESS_DEREF(SimpleTypeDefs)

  SimpleTypeDefList simpleTypeDefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SetValue  : public ParseTreeNode
{

public:
  SetValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SetValue(const SetValue& orig);
  ~SetValue();
  void operator=(const SetValue& orig);
  ITEXACCESS_DEREF(SetValue)

  ElementValueList elementValueList() const;
};


class CM_ParIdAndFullId  : public ParseTreeNode
{

public:
  CM_ParIdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CM_ParIdAndFullId(const CM_ParIdAndFullId& orig);
  ~CM_ParIdAndFullId();
  void operator=(const CM_ParIdAndFullId& orig);
  ITEXACCESS_DEREF(CM_ParIdAndFullId)

  Identifier cm_ParIdentifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class PDU_FieldId  : public ParseTreeNode
{

public:
  PDU_FieldId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldId(const PDU_FieldId& orig);
  ~PDU_FieldId();
  void operator=(const PDU_FieldId& orig);
  ITEXACCESS_DEREF(PDU_FieldId)

  PDU_FieldIdOrMacro pdu_FieldIdOrMacro() const;
};


class TC_VarId  : public ParseTreeNode
{

public:
  TC_VarId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TC_VarId(const TC_VarId& orig);
  ~TC_VarId();
  void operator=(const TC_VarId& orig);
  ITEXACCESS_DEREF(TC_VarId)

  Identifier tc_VarIdentifier() const;
};


class Hstring  : public TerminalNode
{

public:
  Hstring( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Hstring(const Hstring& orig);
  ~Hstring();
  void operator=(const Hstring& orig);
  ITEXACCESS_DEREF(Hstring)

};


class LowerEndValue  : public ParseTreeNode
{

public:
  LowerEndValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerEndValue(const LowerEndValue& orig);
  ~LowerEndValue();
  void operator=(const LowerEndValue& orig);
  ITEXACCESS_DEREF(LowerEndValue)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
  Min min() const;
  Choices::Choice choice() const;
};


class Declarations  : public StaticNode
{

public:
  Declarations( NodeInfo nodeinfo);
  Declarations(const Declarations& orig);
  ~Declarations();
  void operator=(const Declarations& orig);
  ITEXACCESS_DEREF(Declarations)

  TS_ConstDcls ts_ConstDcls() const;
  TS_ConstRefs ts_ConstRefs() const;
  TS_VarDcls ts_VarDcls() const;
  TC_VarDcls tc_VarDcls() const;
  PCO_TypeDcls pco_TypeDcls() const;
  PCO_Dcls pco_Dcls() const;
  CP_Dcls cp_Dcls() const;
  TimerDcls timerDcls() const;
  TCompDcls tcompDcls() const;
  TCompConfigDcls tcompConfigDcls() const;
};


class TestStepIndex  : public TableNode
{

public:
  TestStepIndex( NodeInfo nodeinfo);
  TestStepIndex(const TestStepIndex& orig);
  ~TestStepIndex();
  void operator=(const TestStepIndex& orig);
  ITEXACCESS_DEREF(TestStepIndex)

  SO_StepIndexList SO_stepIndexList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class TypeAndLengthAttribute  : public ParseTreeNode
{

public:
  TypeAndLengthAttribute( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeAndLengthAttribute(const TypeAndLengthAttribute& orig);
  ~TypeAndLengthAttribute();
  void operator=(const TypeAndLengthAttribute& orig);
  ITEXACCESS_DEREF(TypeAndLengthAttribute)

  TTCN_Type ttcn_Type() const;
  LengthAttribute lengthAttribute() const;

  Boolean is_present_lengthAttribute() const;
};


class NanoSeconds  : public TerminalNode
{

public:
  NanoSeconds( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NanoSeconds(const NanoSeconds& orig);
  ~NanoSeconds();
  void operator=(const NanoSeconds& orig);
  ITEXACCESS_DEREF(NanoSeconds)

};


class NamedTypeAttribute  : public ParseTreeNode
{

public:
  NamedTypeAttribute( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedTypeAttribute(const NamedTypeAttribute& orig);
  ~NamedTypeAttribute();
  void operator=(const NamedTypeAttribute& orig);
  ITEXACCESS_DEREF(NamedTypeAttribute)

  OPTIONAL optional() const;
  DefaultValue defaultValue() const;
  Choices::Choice choice() const;
};


class Expansion  : public ParseTreeNode
{

public:
  Expansion( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Expansion(const Expansion& orig);
  ~Expansion();
  void operator=(const Expansion& orig);
  ITEXACCESS_DEREF(Expansion)

  Identifier identifier() const;
};


class ComponentReferenceList  : public ParseTreeList
{

public:
  ComponentReferenceList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentReferenceList(const ComponentReferenceList& orig);
  ~ComponentReferenceList();
  void operator=(const ComponentReferenceList& orig);
  ITEXACCESS_DEREF(ComponentReferenceList)

  ComponentReference componentReference(int index) const;
  ComponentReference operator[](int index) const;
};


class RootTree  : public RowList
{

public:
  RootTree( NodeInfo nodeinfo,  Table* tab);
  RootTree(const RootTree& orig);
  ~RootTree();
  void operator=(const RootTree& orig);
  ITEXACCESS_DEREF(RootTree)

  BehaviourLine behaviourLine(int index) const;
  BehaviourLine operator[](int index) const;
};


class Description  : public TerminalNode
{

public:
  Description( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Description(const Description& orig);
  ~Description();
  void operator=(const Description& orig);
  ITEXACCESS_DEREF(Description)

};


class NumOf_CPs  : public ParseTreeNode
{

public:
  NumOf_CPs( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NumOf_CPs(const NumOf_CPs& orig);
  ~NumOf_CPs();
  void operator=(const NumOf_CPs& orig);
  ITEXACCESS_DEREF(NumOf_CPs)

  Num_CPs num_CPs() const;
};


class SO_StepIndexList  : public RowList
{

public:
  SO_StepIndexList( NodeInfo nodeinfo,  Table* tab);
  SO_StepIndexList(const SO_StepIndexList& orig);
  ~SO_StepIndexList();
  void operator=(const SO_StepIndexList& orig);
  ITEXACCESS_DEREF(SO_StepIndexList)

  SO_StepIndex SO_stepIndex(int index) const;
  SO_StepIndex operator[](int index) const;
};


class ElemType  : public ParseTreeNode
{

public:
  ElemType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElemType(const ElemType& orig);
  ~ElemType();
  void operator=(const ElemType& orig);
  ITEXACCESS_DEREF(ElemType)

  TypeAndAttributes typeAndAttributes() const;
};


class R  : public TerminalNode
{

public:
  R( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  R(const R& orig);
  ~R();
  void operator=(const R& orig);
  ITEXACCESS_DEREF(R)

};


class Minutes  : public TerminalNode
{

public:
  Minutes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Minutes(const Minutes& orig);
  ~Minutes();
  void operator=(const Minutes& orig);
  ITEXACCESS_DEREF(Minutes)

};


class IdentifierList  : public ParseTreeList
{

public:
  IdentifierList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IdentifierList(const IdentifierList& orig);
  ~IdentifierList();
  void operator=(const IdentifierList& orig);
  ITEXACCESS_DEREF(IdentifierList)

  Identifier identifier(int index) const;
  Identifier operator[](int index) const;
};


class TypeReference  : public ParseTreeNode
{

public:
  TypeReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeReference(const TypeReference& orig);
  ~TypeReference();
  void operator=(const TypeReference& orig);
  ITEXACCESS_DEREF(TypeReference)

  Identifier identifier() const;
};


class ActualCrefParList  : public ParseTreeList
{

public:
  ActualCrefParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ActualCrefParList(const ActualCrefParList& orig);
  ~ActualCrefParList();
  void operator=(const ActualCrefParList& orig);
  ITEXACCESS_DEREF(ActualCrefParList)

  ConstraintValueAndAttributes constraintValueAndAttributes(int index) const;
  ConstraintValueAndAttributes operator[](int index) const;
};


class SelExprId  : public ParseTreeNode
{

public:
  SelExprId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelExprId(const SelExprId& orig);
  ~SelExprId();
  void operator=(const SelExprId& orig);
  ITEXACCESS_DEREF(SelExprId)

  Identifier selectExprIdentifier() const;
};


class ASN1_TypeConstraint  : public TableNode
{

public:
  ASN1_TypeConstraint( NodeInfo nodeinfo);
  ASN1_TypeConstraint(const ASN1_TypeConstraint& orig);
  ~ASN1_TypeConstraint();
  void operator=(const ASN1_TypeConstraint& orig);
  ITEXACCESS_DEREF(ASN1_TypeConstraint)

  ConsId consId() const;
  ASN1_TypeId asn1_TypeId() const;
  DerivPath derivPath() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ASN1_ConsValue asn1_ConsValue() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_asn1_TypeId() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_ConsValue() const;
  Boolean is_present_detailedComment() const;
};


class DerivationPath  : public ParseTreeList
{

public:
  DerivationPath( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DerivationPath(const DerivationPath& orig);
  ~DerivationPath();
  void operator=(const DerivationPath& orig);
  ITEXACCESS_DEREF(DerivationPath)

  Identifier constraintIdentifier(int index) const;
  Identifier operator[](int index) const;
};


class TCompDclList  : public StaticList
{

public:
  TCompDclList( NodeInfo nodeinfo);
  TCompDclList(const TCompDclList& orig);
  ~TCompDclList();
  void operator=(const TCompDclList& orig);
  ITEXACCESS_DEREF(TCompDclList)

  TCompDcl tcompDcl(int index) const;
  TCompDcl operator[](int index) const;
};


class TS_ProcIdAndParList  : public ParseTreeNode
{

public:
  TS_ProcIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ProcIdAndParList(const TS_ProcIdAndParList& orig);
  ~TS_ProcIdAndParList();
  void operator=(const TS_ProcIdAndParList& orig);
  ITEXACCESS_DEREF(TS_ProcIdAndParList)

  Identifier ts_ProcIdentifier() const;
  FormalParList formalParList() const;
};


class SequenceType  : public ParseTreeNode
{

public:
  SequenceType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SequenceType(const SequenceType& orig);
  ~SequenceType();
  void operator=(const SequenceType& orig);
  ITEXACCESS_DEREF(SequenceType)

  ElementTypeList elementTypeList() const;
};


class ASP_ParType  : public ParseTreeNode
{

public:
  ASP_ParType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASP_ParType(const ASP_ParType& orig);
  ~ASP_ParType();
  void operator=(const ASP_ParType& orig);
  ITEXACCESS_DEREF(ASP_ParType)

  TypeAndAttributes typeAndAttributes() const;
};


class PDU_FieldEncoding  : public ParseTreeNode
{

public:
  PDU_FieldEncoding( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldEncoding(const PDU_FieldEncoding& orig);
  ~PDU_FieldEncoding();
  void operator=(const PDU_FieldEncoding& orig);
  ITEXACCESS_DEREF(PDU_FieldEncoding)

  PDU_FieldEncodingCall pdu_FieldEncodingCall() const;
};


class INCONC  : public TerminalNode
{

public:
  INCONC( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  INCONC(const INCONC& orig);
  ~INCONC();
  void operator=(const INCONC& orig);
  ITEXACCESS_DEREF(INCONC)

};


class UNIVERSAL  : public TerminalNode
{

public:
  UNIVERSAL( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UNIVERSAL(const UNIVERSAL& orig);
  ~UNIVERSAL();
  void operator=(const UNIVERSAL& orig);
  ITEXACCESS_DEREF(UNIVERSAL)

};


class DefaultRefList  : public ParseTreeList
{

public:
  DefaultRefList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultRefList(const DefaultRefList& orig);
  ~DefaultRefList();
  void operator=(const DefaultRefList& orig);
  ITEXACCESS_DEREF(DefaultRefList)

  DefaultReference defaultReference(int index) const;
  DefaultReference operator[](int index) const;
};


class ASP_ParValue  : public RowNode
{

public:
  ASP_ParValue( NodeInfo nodeinfo,  Table* tab,  Row* row);
  ASP_ParValue(const ASP_ParValue& orig);
  ~ASP_ParValue();
  void operator=(const ASP_ParValue& orig);
  ITEXACCESS_DEREF(ASP_ParValue)

  ASP_ParId asp_ParId() const;
  ConsValue consValue() const;
  Comment comment() const;

  Boolean is_present_asp_ParId() const;
  Boolean is_present_consValue() const;
  Boolean is_present_comment() const;
};


class TC_VarValue  : public ParseTreeNode
{

public:
  TC_VarValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TC_VarValue(const TC_VarValue& orig);
  ~TC_VarValue();
  void operator=(const TC_VarValue& orig);
  ITEXACCESS_DEREF(TC_VarValue)

  DeclarationValue declarationValue() const;
};


class TC_VarType  : public ParseTreeNode
{

public:
  TC_VarType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TC_VarType(const TC_VarType& orig);
  ~TC_VarType();
  void operator=(const TC_VarType& orig);
  ITEXACCESS_DEREF(TC_VarType)

  TypeOrPDU typeOrPDU() const;
};


class EncodingDefinition  : public TableNode
{

public:
  EncodingDefinition( NodeInfo nodeinfo);
  EncodingDefinition(const EncodingDefinition& orig);
  ~EncodingDefinition();
  void operator=(const EncodingDefinition& orig);
  ITEXACCESS_DEREF(EncodingDefinition)

  EncodingRuleId encodingRuleId() const;
  EncodingRef encodingRef() const;
  EncodingDefault encodingDefault() const;
  Comment comment() const;

  Boolean is_present_encodingRuleId() const;
  Boolean is_present_encodingRef() const;
  Boolean is_present_encodingDefault() const;
  Boolean is_present_comment() const;
};


class ASN1_TypeReference  : public TerminalNode
{

public:
  ASN1_TypeReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_TypeReference(const ASN1_TypeReference& orig);
  ~ASN1_TypeReference();
  void operator=(const ASN1_TypeReference& orig);
  ITEXACCESS_DEREF(ASN1_TypeReference)

};


class Not  : public TerminalNode
{

public:
  Not( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Not(const Not& orig);
  ~Not();
  void operator=(const Not& orig);
  ITEXACCESS_DEREF(Not)

};


class Ten  : public TerminalNode
{

public:
  Ten( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Ten(const Ten& orig);
  ~Ten();
  void operator=(const Ten& orig);
  ITEXACCESS_DEREF(Ten)

};


class NumericRealValue  : public ParseTreeNode
{

public:
  NumericRealValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NumericRealValue(const NumericRealValue& orig);
  ~NumericRealValue();
  void operator=(const NumericRealValue& orig);
  ITEXACCESS_DEREF(NumericRealValue)

  Mantissa mantissa() const;
  Base base() const;
  Exponent exponent() const;
};


class TypeAssignmentList  : public ParseTreeList
{

public:
  TypeAssignmentList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeAssignmentList(const TypeAssignmentList& orig);
  ~TypeAssignmentList();
  void operator=(const TypeAssignmentList& orig);
  ITEXACCESS_DEREF(TypeAssignmentList)

  TypeAssignment typeAssignment(int index) const;
  TypeAssignment operator[](int index) const;
};


class DynamicPart  : public StaticNode
{

public:
  DynamicPart( NodeInfo nodeinfo);
  DynamicPart(const DynamicPart& orig);
  ~DynamicPart();
  void operator=(const DynamicPart& orig);
  ITEXACCESS_DEREF(DynamicPart)

  TestCases testCases() const;
  TestStepLibrary testStepLibrary() const;
  DefaultsLibrary defaultsLibrary() const;
};


class AliasDefList  : public StaticList
{

public:
  AliasDefList( NodeInfo nodeinfo);
  AliasDefList(const AliasDefList& orig);
  ~AliasDefList();
  void operator=(const AliasDefList& orig);
  ITEXACCESS_DEREF(AliasDefList)

  AliasDef aliasDef(int index) const;
  AliasDef operator[](int index) const;
};


class CP_List  : public ParseTreeList
{

public:
  CP_List( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CP_List(const CP_List& orig);
  ~CP_List();
  void operator=(const CP_List& orig);
  ITEXACCESS_DEREF(CP_List)

  Identifier cp_Identifier(int index) const;
  Identifier operator[](int index) const;
};


class CPs_Used  : public ParseTreeNode
{

public:
  CPs_Used( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CPs_Used(const CPs_Used& orig);
  ~CPs_Used();
  void operator=(const CPs_Used& orig);
  ITEXACCESS_DEREF(CPs_Used)

  CP_List cp_List() const;
};


class OmitReference  : public ParseTreeNode
{

public:
  OmitReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OmitReference(const OmitReference& orig);
  ~OmitReference();
  void operator=(const OmitReference& orig);
  ITEXACCESS_DEREF(OmitReference)

  ReferenceList referenceList() const;
};


class TTCN_CM_TypeDef  : public TableNode
{

public:
  TTCN_CM_TypeDef( NodeInfo nodeinfo);
  TTCN_CM_TypeDef(const TTCN_CM_TypeDef& orig);
  ~TTCN_CM_TypeDef();
  void operator=(const TTCN_CM_TypeDef& orig);
  ITEXACCESS_DEREF(TTCN_CM_TypeDef)

  CM_Id cm_Id() const;
  Comment comment() const;
  CM_ParDcls cm_ParDcls() const;
  DetailedComment detailedComment() const;

  Boolean is_present_cm_Id() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class TS_ConstDclList  : public StaticList
{

public:
  TS_ConstDclList( NodeInfo nodeinfo);
  TS_ConstDclList(const TS_ConstDclList& orig);
  ~TS_ConstDclList();
  void operator=(const TS_ConstDclList& orig);
  ITEXACCESS_DEREF(TS_ConstDclList)

  TS_ConstDcl ts_ConstDcl(int index) const;
  TS_ConstDcl operator[](int index) const;
};


class LengthRestriction  : public ParseTreeNode
{

public:
  LengthRestriction( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LengthRestriction(const LengthRestriction& orig);
  ~LengthRestriction();
  void operator=(const LengthRestriction& orig);
  ITEXACCESS_DEREF(LengthRestriction)

  SingleTypeLength singleTypeLength() const;
  RangeTypeLength rangeTypeLength() const;
  Choices::Choice choice() const;
};


class TS_ParDcls  : public TableNode
{

public:
  TS_ParDcls( NodeInfo nodeinfo);
  TS_ParDcls(const TS_ParDcls& orig);
  ~TS_ParDcls();
  void operator=(const TS_ParDcls& orig);
  ITEXACCESS_DEREF(TS_ParDcls)

  TS_ParDclList ts_ParDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class TestStepGroupId  : public ParseTreeNode
{

public:
  TestStepGroupId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestStepGroupId(const TestStepGroupId& orig);
  ~TestStepGroupId();
  void operator=(const TestStepGroupId& orig);
  ITEXACCESS_DEREF(TestStepGroupId)

  Identifier testStepGroupIdentifier() const;
};


class CP_Dcl  : public TableNode
{

public:
  CP_Dcl( NodeInfo nodeinfo);
  CP_Dcl(const CP_Dcl& orig);
  ~CP_Dcl();
  void operator=(const CP_Dcl& orig);
  ITEXACCESS_DEREF(CP_Dcl)

  CP_Id cp_Id() const;
  Comment comment() const;

  Boolean is_present_cp_Id() const;
  Boolean is_present_comment() const;
};


class TS_VarDclList  : public StaticList
{

public:
  TS_VarDclList( NodeInfo nodeinfo);
  TS_VarDclList(const TS_VarDclList& orig);
  ~TS_VarDclList();
  void operator=(const TS_VarDclList& orig);
  ITEXACCESS_DEREF(TS_VarDclList)

  TS_VarDcl ts_VarDcl(int index) const;
  TS_VarDcl operator[](int index) const;
};


class RealValue  : public ParseTreeNode
{

public:
  RealValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RealValue(const RealValue& orig);
  ~RealValue();
  void operator=(const RealValue& orig);
  ITEXACCESS_DEREF(RealValue)

  NumericRealValue numericRealValue() const;
  SpecialRealValue specialRealValue() const;
  Choices::Choice choice() const;
};


class TCompDcls  : public TableNode
{

public:
  TCompDcls( NodeInfo nodeinfo);
  TCompDcls(const TCompDcls& orig);
  ~TCompDcls();
  void operator=(const TCompDcls& orig);
  ITEXACCESS_DEREF(TCompDcls)

  TCompDclList tcompDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class DeclarationValue  : public ParseTreeNode
{

public:
  DeclarationValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DeclarationValue(const DeclarationValue& orig);
  ~DeclarationValue();
  void operator=(const DeclarationValue& orig);
  ITEXACCESS_DEREF(DeclarationValue)

  Expression expression() const;
};


class SelectionExpression  : public ParseTreeNode
{

public:
  SelectionExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SelectionExpression(const SelectionExpression& orig);
  ~SelectionExpression();
  void operator=(const SelectionExpression& orig);
  ITEXACCESS_DEREF(SelectionExpression)

  Expression expression() const;
};


class PredefinedType  : public ParseTreeNode
{

public:
  PredefinedType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PredefinedType(const PredefinedType& orig);
  ~PredefinedType();
  void operator=(const PredefinedType& orig);
  ITEXACCESS_DEREF(PredefinedType)

  INTEGER integer() const;
  BOOLEAN boolean() const;
  BITSTRING bitstring() const;
  HEXSTRING hexstring() const;
  OCTETSTRING octetstring() const;
  R_TYPE r_Type() const;
  CharacterString characterString() const;
  Choices::Choice choice() const;
};


class BooleanType  : public TerminalNode
{

public:
  BooleanType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BooleanType(const BooleanType& orig);
  ~BooleanType();
  void operator=(const BooleanType& orig);
  ITEXACCESS_DEREF(BooleanType)

};


class Send  : public ParseTreeNode
{

public:
  Send( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Send(const Send& orig);
  ~Send();
  void operator=(const Send& orig);
  ITEXACCESS_DEREF(Send)

  Identifier identifier1() const;
  Identifier identifier2() const;

  Boolean is_present_identifier1() const;
};


class ASN1_CM_TypeDef  : public TableNode
{

public:
  ASN1_CM_TypeDef( NodeInfo nodeinfo);
  ASN1_CM_TypeDef(const ASN1_CM_TypeDef& orig);
  ~ASN1_CM_TypeDef();
  void operator=(const ASN1_CM_TypeDef& orig);
  ITEXACCESS_DEREF(ASN1_CM_TypeDef)

  CM_Id cm_Id() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;
  DetailedComment detailedComment() const;

  Boolean is_present_cm_Id() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
  Boolean is_present_detailedComment() const;
};


class ConstraintValueAndAttributesOrReplace  : public ParseTreeNode
{

public:
  ConstraintValueAndAttributesOrReplace( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConstraintValueAndAttributesOrReplace(const ConstraintValueAndAttributesOrReplace& orig);
  ~ConstraintValueAndAttributesOrReplace();
  void operator=(const ConstraintValueAndAttributesOrReplace& orig);
  ITEXACCESS_DEREF(ConstraintValueAndAttributesOrReplace)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
  ReplacementList replacementList() const;
  Choices::Choice choice() const;
};


class InvalidFieldEncodingIdAndParList  : public ParseTreeNode
{

public:
  InvalidFieldEncodingIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  InvalidFieldEncodingIdAndParList(const InvalidFieldEncodingIdAndParList& orig);
  ~InvalidFieldEncodingIdAndParList();
  void operator=(const InvalidFieldEncodingIdAndParList& orig);
  ITEXACCESS_DEREF(InvalidFieldEncodingIdAndParList)

  Identifier invalidFieldEncodingIdentifier() const;
  FormalParList formalParList() const;
};


class ConstraintValueAndAttributes  : public ParseTreeNode
{

public:
  ConstraintValueAndAttributes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConstraintValueAndAttributes(const ConstraintValueAndAttributes& orig);
  ~ConstraintValueAndAttributes();
  void operator=(const ConstraintValueAndAttributes& orig);
  ITEXACCESS_DEREF(ConstraintValueAndAttributes)

  ConstraintValue constraintValue() const;
  ValueAttributes valueAttributes() const;

  Boolean is_present_valueAttributes() const;
};


class Qualifier  : public ParseTreeNode
{

public:
  Qualifier( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Qualifier(const Qualifier& orig);
  ~Qualifier();
  void operator=(const Qualifier& orig);
  ITEXACCESS_DEREF(Qualifier)

  Expression expression() const;
};


class PDU_IdAndFullId  : public ParseTreeNode
{

public:
  PDU_IdAndFullId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_IdAndFullId(const PDU_IdAndFullId& orig);
  ~PDU_IdAndFullId();
  void operator=(const PDU_IdAndFullId& orig);
  ITEXACCESS_DEREF(PDU_IdAndFullId)

  Identifier pdu_Identifier() const;
  FullIdentifier fullIdentifier() const;

  Boolean is_present_fullIdentifier() const;
};


class CP_Dcls  : public TableNode
{

public:
  CP_Dcls( NodeInfo nodeinfo);
  CP_Dcls(const CP_Dcls& orig);
  ~CP_Dcls();
  void operator=(const CP_Dcls& orig);
  ITEXACCESS_DEREF(CP_Dcls)

  CP_DclList cp_DclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SelectExprDef  : public TableNode
{

public:
  SelectExprDef( NodeInfo nodeinfo);
  SelectExprDef(const SelectExprDef& orig);
  ~SelectExprDef();
  void operator=(const SelectExprDef& orig);
  ITEXACCESS_DEREF(SelectExprDef)

  SelectExprId selectExprId() const;
  SelectExpr selectExpr() const;
  Comment comment() const;

  Boolean is_present_selectExprId() const;
  Boolean is_present_selectExpr() const;
  Boolean is_present_comment() const;
};


class CharacterString  : public ParseTreeNode
{

public:
  CharacterString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CharacterString(const CharacterString& orig);
  ~CharacterString();
  void operator=(const CharacterString& orig);
  ITEXACCESS_DEREF(CharacterString)

  NumericString numericString() const;
  PrintableString printableString() const;
  TeletexString teletexString() const;
  VideotexString videotexString() const;
  VisibleString visibleString() const;
  IA5String ia5String() const;
  GraphicString graphicString() const;
  GeneralString generalString() const;
  T61String t61String() const;
  ISO646String iso646String() const;
  Choices::Choice choice() const;
};


class ISO646String  : public TerminalNode
{

public:
  ISO646String( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ISO646String(const ISO646String& orig);
  ~ISO646String();
  void operator=(const ISO646String& orig);
  ITEXACCESS_DEREF(ISO646String)

};


class TypeAssignment  : public ParseTreeNode
{

public:
  TypeAssignment( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeAssignment(const TypeAssignment& orig);
  ~TypeAssignment();
  void operator=(const TypeAssignment& orig);
  ITEXACCESS_DEREF(TypeAssignment)

  TypeReference typeReference() const;
  ASN1_Type asn1_Type() const;
};


class ParenExpression  : public ParseTreeNode
{

public:
  ParenExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ParenExpression(const ParenExpression& orig);
  ~ParenExpression();
  void operator=(const ParenExpression& orig);
  ITEXACCESS_DEREF(ParenExpression)

  Expression expression() const;
};


class DefaultId  : public ParseTreeNode
{

public:
  DefaultId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultId(const DefaultId& orig);
  ~DefaultId();
  void operator=(const DefaultId& orig);
  ITEXACCESS_DEREF(DefaultId)

  DefaultIdAndParList defaultIdAndParList() const;
};


class TestStep  : public TableNode
{

public:
  TestStep( NodeInfo nodeinfo);
  TestStep(const TestStep& orig);
  ~TestStep();
  void operator=(const TestStep& orig);
  ITEXACCESS_DEREF(TestStep)

  TestStepId testStepId() const;
  TestStepRef testStepRef() const;
  Objective objective() const;
  DefaultsRef defaultsRef() const;
  Comment comment() const;
  Description description() const;
  BehaviourDescription behaviourDescription() const;
  DetailedComment detailedComment() const;

  Boolean is_present_testStepId() const;
  Boolean is_present_testStepRef() const;
  Boolean is_present_objective() const;
  Boolean is_present_defaultsRef() const;
  Boolean is_present_comment() const;
  Boolean is_present_description() const;
  Boolean is_present_detailedComment() const;
};


class CreateList  : public ParseTreeList
{

public:
  CreateList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CreateList(const CreateList& orig);
  ~CreateList();
  void operator=(const CreateList& orig);
  ITEXACCESS_DEREF(CreateList)

  CreateTComp createTComp(int index) const;
  CreateTComp operator[](int index) const;
};


class ConstraintsPart  : public StaticNode
{

public:
  ConstraintsPart( NodeInfo nodeinfo);
  ConstraintsPart(const ConstraintsPart& orig);
  ~ConstraintsPart();
  void operator=(const ConstraintsPart& orig);
  ITEXACCESS_DEREF(ConstraintsPart)

  TS_TypeConstraints ts_TypeConstraints() const;
  ASP_Constraints asp_Constraints() const;
  PDU_Constraints pdu_Constraints() const;
  CM_Constraints cm_Constraints() const;
};


class ASN1_PDU_TypeDefs  : public StaticList
{

public:
  ASN1_PDU_TypeDefs( NodeInfo nodeinfo);
  ASN1_PDU_TypeDefs(const ASN1_PDU_TypeDefs& orig);
  ~ASN1_PDU_TypeDefs();
  void operator=(const ASN1_PDU_TypeDefs& orig);
  ITEXACCESS_DEREF(ASN1_PDU_TypeDefs)

  ASN1_PDU_TypeDef asn1_PDU_TypeDef(int index) const;
  ASN1_PDU_TypeDef operator[](int index) const;
};


class NumericString  : public TerminalNode
{

public:
  NumericString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NumericString(const NumericString& orig);
  ~NumericString();
  void operator=(const NumericString& orig);
  ITEXACCESS_DEREF(NumericString)

};


class BitIdentifier  : public ParseTreeNode
{

public:
  BitIdentifier( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BitIdentifier(const BitIdentifier& orig);
  ~BitIdentifier();
  void operator=(const BitIdentifier& orig);
  ITEXACCESS_DEREF(BitIdentifier)

  Identifier identifier() const;
};


class MatchingSymbol  : public ParseTreeNode
{

public:
  MatchingSymbol( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MatchingSymbol(const MatchingSymbol& orig);
  ~MatchingSymbol();
  void operator=(const MatchingSymbol& orig);
  ITEXACCESS_DEREF(MatchingSymbol)

  Complement complement() const;
  Omit omit() const;
  ANYValue anyValue() const;
  AnyOrOmit anyOrOmit() const;
  ValueList valueList() const;
  ValRange valRange() const;
  SuperSet superSet() const;
  SubSet subSet() const;
  Permutation permutation() const;
  Choices::Choice choice() const;
};


class TestGroupRef  : public ParseTreeNode
{

public:
  TestGroupRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestGroupRef(const TestGroupRef& orig);
  ~TestGroupRef();
  void operator=(const TestGroupRef& orig);
  ITEXACCESS_DEREF(TestGroupRef)

  TestGroupReference testGroupReference() const;
};


class TimerDclList  : public StaticList
{

public:
  TimerDclList( NodeInfo nodeinfo);
  TimerDclList(const TimerDclList& orig);
  ~TimerDclList();
  void operator=(const TimerDclList& orig);
  ITEXACCESS_DEREF(TimerDclList)

  TimerDcl timerDcl(int index) const;
  TimerDcl operator[](int index) const;
};


class TS_ParDclList  : public StaticList
{

public:
  TS_ParDclList( NodeInfo nodeinfo);
  TS_ParDclList(const TS_ParDclList& orig);
  ~TS_ParDclList();
  void operator=(const TS_ParDclList& orig);
  ITEXACCESS_DEREF(TS_ParDclList)

  TS_ParDcl ts_ParDcl(int index) const;
  TS_ParDcl operator[](int index) const;
};


class FormalParAndType  : public ParseTreeNode
{

public:
  FormalParAndType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FormalParAndType(const FormalParAndType& orig);
  ~FormalParAndType();
  void operator=(const FormalParAndType& orig);
  ITEXACCESS_DEREF(FormalParAndType)

  FormalParIdList formalParIdList() const;
  FormalParType formalParType() const;
};


class ReplacementList  : public ParseTreeList
{

public:
  ReplacementList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ReplacementList(const ReplacementList& orig);
  ~ReplacementList();
  void operator=(const ReplacementList& orig);
  ITEXACCESS_DEREF(ReplacementList)

  Replacement replacement(int index) const;
  Replacement operator[](int index) const;
};


class Minus_INFINITY  : public TerminalNode
{

public:
  Minus_INFINITY( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Minus_INFINITY(const Minus_INFINITY& orig);
  ~Minus_INFINITY();
  void operator=(const Minus_INFINITY& orig);
  ITEXACCESS_DEREF(Minus_INFINITY)

};


class GraphicString  : public TerminalNode
{

public:
  GraphicString( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  GraphicString(const GraphicString& orig);
  ~GraphicString();
  void operator=(const GraphicString& orig);
  ITEXACCESS_DEREF(GraphicString)

};


class ElementTypeList  : public ParseTreeList
{

public:
  ElementTypeList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElementTypeList(const ElementTypeList& orig);
  ~ElementTypeList();
  void operator=(const ElementTypeList& orig);
  ITEXACCESS_DEREF(ElementTypeList)

  ElementType elementType(int index) const;
  ElementType operator[](int index) const;
};


class AddExpression  : public ParseTreeNode
{

public:
  AddExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AddExpression(const AddExpression& orig);
  ~AddExpression();
  void operator=(const AddExpression& orig);
  ITEXACCESS_DEREF(AddExpression)

  SimpleExpression simpleExpression() const;
  AddOp addOp() const;
  Term term() const;
};


class RETURN_  : public TerminalNode
{

public:
  RETURN_( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RETURN_(const RETURN_& orig);
  ~RETURN_();
  void operator=(const RETURN_& orig);
  ITEXACCESS_DEREF(RETURN_)

};


class LT  : public TerminalNode
{

public:
  LT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LT(const LT& orig);
  ~LT();
  void operator=(const LT& orig);
  ITEXACCESS_DEREF(LT)

};


class Identifier  : public TerminalNode
{

public:
  Identifier( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Identifier(const Identifier& orig);
  ~Identifier();
  void operator=(const Identifier& orig);
  ITEXACCESS_DEREF(Identifier)
  Choices::Choice choice() const;

};


class PresenceConstraint  : public ParseTreeNode
{

public:
  PresenceConstraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PresenceConstraint(const PresenceConstraint& orig);
  ~PresenceConstraint();
  void operator=(const PresenceConstraint& orig);
  ITEXACCESS_DEREF(PresenceConstraint)

  PRESENT present() const;
  ABSENT absent() const;
  OPTIONAL optional() const;
  Choices::Choice choice() const;
};


class ComponentReference  : public ParseTreeNode
{

public:
  ComponentReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ComponentReference(const ComponentReference& orig);
  ~ComponentReference();
  void operator=(const ComponentReference& orig);
  ITEXACCESS_DEREF(ComponentReference)

  RecordRef recordRef() const;
  ArrayRef arrayRef() const;
  BitRef bitRef() const;
  Choices::Choice choice() const;
};


class SingleValueLength  : public ParseTreeNode
{

public:
  SingleValueLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SingleValueLength(const SingleValueLength& orig);
  ~SingleValueLength();
  void operator=(const SingleValueLength& orig);
  ITEXACCESS_DEREF(SingleValueLength)

  ValueBound valueBound() const;
};


class TestGroupId  : public ParseTreeNode
{

public:
  TestGroupId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TestGroupId(const TestGroupId& orig);
  ~TestGroupId();
  void operator=(const TestGroupId& orig);
  ITEXACCESS_DEREF(TestGroupId)

  Identifier testGroupIdentifier() const;
};


class GoTo  : public ParseTreeNode
{

public:
  GoTo( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  GoTo(const GoTo& orig);
  ~GoTo();
  void operator=(const GoTo& orig);
  ITEXACCESS_DEREF(GoTo)

  Label label() const;
};


class TS_OpId  : public ParseTreeNode
{

public:
  TS_OpId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_OpId(const TS_OpId& orig);
  ~TS_OpId();
  void operator=(const TS_OpId& orig);
  ITEXACCESS_DEREF(TS_OpId)

  TS_OpIdAndParList ts_OpIdAndParList() const;
};


class ASuite  : public TableNode
{

public:
  ASuite( NodeInfo nodeinfo);
  ASuite(const ASuite& orig);
  ~ASuite();
  void operator=(const ASuite& orig);
  ITEXACCESS_DEREF(ASuite)

  SuiteId suiteId() const;
  SuiteOverviewPart suiteOverviewPart() const;
  DeclarationsPart declarationsPart() const;
  ConstraintsPart constraintsPart() const;
  DynamicPart dynamicPart() const;

  Boolean is_present_suiteId() const;
};


class FAIL  : public TerminalNode
{

public:
  FAIL( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FAIL(const FAIL& orig);
  ~FAIL();
  void operator=(const FAIL& orig);
  ITEXACCESS_DEREF(FAIL)

};


class Plus_INFINITY  : public TerminalNode
{

public:
  Plus_INFINITY( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Plus_INFINITY(const Plus_INFINITY& orig);
  ~Plus_INFINITY();
  void operator=(const Plus_INFINITY& orig);
  ITEXACCESS_DEREF(Plus_INFINITY)

};


class SimpleExpression  : public ParseTreeNode
{

public:
  SimpleExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SimpleExpression(const SimpleExpression& orig);
  ~SimpleExpression();
  void operator=(const SimpleExpression& orig);
  ITEXACCESS_DEREF(SimpleExpression)

  AddExpression addExpression() const;
  Term term() const;
  Choices::Choice choice() const;
};


class ConsValue  : public ParseTreeNode
{

public:
  ConsValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConsValue(const ConsValue& orig);
  ~ConsValue();
  void operator=(const ConsValue& orig);
  ITEXACCESS_DEREF(ConsValue)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class TS_ConstDcl  : public TableNode
{

public:
  TS_ConstDcl( NodeInfo nodeinfo);
  TS_ConstDcl(const TS_ConstDcl& orig);
  ~TS_ConstDcl();
  void operator=(const TS_ConstDcl& orig);
  ITEXACCESS_DEREF(TS_ConstDcl)

  TS_ConstId ts_ConstId() const;
  TS_ConstType ts_ConstType() const;
  TS_ConstValue ts_ConstValue() const;
  Comment comment() const;

  Boolean is_present_ts_ConstId() const;
  Boolean is_present_ts_ConstType() const;
  Boolean is_present_ts_ConstValue() const;
  Boolean is_present_comment() const;
};


class SO_StandardsRef  : public TerminalNode
{

public:
  SO_StandardsRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_StandardsRef(const SO_StandardsRef& orig);
  ~SO_StandardsRef();
  void operator=(const SO_StandardsRef& orig);
  ITEXACCESS_DEREF(SO_StandardsRef)

};


class EncVariationCall  : public ParseTreeNode
{

public:
  EncVariationCall( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncVariationCall(const EncVariationCall& orig);
  ~EncVariationCall();
  void operator=(const EncVariationCall& orig);
  ITEXACCESS_DEREF(EncVariationCall)

  Identifier encVariationIdentifier() const;
  ActualParList actualParList() const;
};


class AFalse  : public TerminalNode
{

public:
  AFalse( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AFalse(const AFalse& orig);
  ~AFalse();
  void operator=(const AFalse& orig);
  ITEXACCESS_DEREF(AFalse)

};


class PreliminaryFAIL  : public TerminalNode
{

public:
  PreliminaryFAIL( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PreliminaryFAIL(const PreliminaryFAIL& orig);
  ~PreliminaryFAIL();
  void operator=(const PreliminaryFAIL& orig);
  ITEXACCESS_DEREF(PreliminaryFAIL)

};


class OpCall  : public ParseTreeNode
{

public:
  OpCall( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  OpCall(const OpCall& orig);
  ~OpCall();
  void operator=(const OpCall& orig);
  ITEXACCESS_DEREF(OpCall)

  Identifier ts_OpIdentifier() const;
  ActualParList actualParList() const;
};


class SuperSet  : public ParseTreeNode
{

public:
  SuperSet( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SuperSet(const SuperSet& orig);
  ~SuperSet();
  void operator=(const SuperSet& orig);
  ITEXACCESS_DEREF(SuperSet)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class LowerRangeBound  : public ParseTreeNode
{

public:
  LowerRangeBound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerRangeBound(const LowerRangeBound& orig);
  ~LowerRangeBound();
  void operator=(const LowerRangeBound& orig);
  ITEXACCESS_DEREF(LowerRangeBound)

  ConstraintExpression constraintExpression() const;
  MinusINFINITY minusINFINITY() const;
  Choices::Choice choice() const;
};


class TimerOp  : public ParseTreeNode
{

public:
  TimerOp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TimerOp(const TimerOp& orig);
  ~TimerOp();
  void operator=(const TimerOp& orig);
  ITEXACCESS_DEREF(TimerOp)

  StartTimer startTimer() const;
  CancelTimer cancelTimer() const;
  ReadTimer readTimer() const;
  Choices::Choice choice() const;
};


class ElemValue  : public RowNode
{

public:
  ElemValue( NodeInfo nodeinfo,  Table* tab,  Row* row);
  ElemValue(const ElemValue& orig);
  ~ElemValue();
  void operator=(const ElemValue& orig);
  ITEXACCESS_DEREF(ElemValue)

  ElemId elemId() const;
  ConsValue consValue() const;
  Comment comment() const;

  Boolean is_present_elemId() const;
  Boolean is_present_consValue() const;
  Boolean is_present_comment() const;
};


class SourceRef  : public TerminalNode
{

public:
  SourceRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SourceRef(const SourceRef& orig);
  ~SourceRef();
  void operator=(const SourceRef& orig);
  ITEXACCESS_DEREF(SourceRef)

};


class UpperEndValue  : public ParseTreeNode
{

public:
  UpperEndValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperEndValue(const UpperEndValue& orig);
  ~UpperEndValue();
  void operator=(const UpperEndValue& orig);
  ITEXACCESS_DEREF(UpperEndValue)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
  Max max() const;
  Choices::Choice choice() const;
};


class SubTypeSpec  : public ParseTreeList
{

public:
  SubTypeSpec( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SubTypeSpec(const SubTypeSpec& orig);
  ~SubTypeSpec();
  void operator=(const SubTypeSpec& orig);
  ITEXACCESS_DEREF(SubTypeSpec)

  SubtypeValueSet subtypeValueSet(int index) const;
  SubtypeValueSet operator[](int index) const;
};


class Term  : public ParseTreeNode
{

public:
  Term( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Term(const Term& orig);
  ~Term();
  void operator=(const Term& orig);
  ITEXACCESS_DEREF(Term)

  MultExpression multExpression() const;
  Factor factor() const;
  Choices::Choice choice() const;
};


class PDU_Constraints  : public StaticNode
{

public:
  PDU_Constraints( NodeInfo nodeinfo);
  PDU_Constraints(const PDU_Constraints& orig);
  ~PDU_Constraints();
  void operator=(const PDU_Constraints& orig);
  ITEXACCESS_DEREF(PDU_Constraints)

  TTCN_PDU_Constraints ttcn_PDU_Constraints() const;
  ASN1_PDU_Constraints asn1_PDU_Constraints() const;
};


class PCO_Role  : public ParseTreeNode
{

public:
  PCO_Role( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCO_Role(const PCO_Role& orig);
  ~PCO_Role();
  void operator=(const PCO_Role& orig);
  ITEXACCESS_DEREF(PCO_Role)

  UT ut() const;
  LT lt() const;
  Choices::Choice choice() const;
};


class ElementValueList  : public ParseTreeList
{

public:
  ElementValueList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ElementValueList(const ElementValueList& orig);
  ~ElementValueList();
  void operator=(const ElementValueList& orig);
  ITEXACCESS_DEREF(ElementValueList)

  NamedValue namedValue(int index) const;
  NamedValue operator[](int index) const;
};


class SequenceValue  : public ParseTreeNode
{

public:
  SequenceValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SequenceValue(const SequenceValue& orig);
  ~SequenceValue();
  void operator=(const SequenceValue& orig);
  ITEXACCESS_DEREF(SequenceValue)

  ElementValueList elementValueList() const;
};


class SequenceOfType  : public ParseTreeNode
{

public:
  SequenceOfType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SequenceOfType(const SequenceOfType& orig);
  ~SequenceOfType();
  void operator=(const SequenceOfType& orig);
  ITEXACCESS_DEREF(SequenceOfType)

  ASN1_Type asn1_Type() const;

  Boolean is_present_asn1_Type() const;
};


class EncodingDefault  : public ParseTreeNode
{

public:
  EncodingDefault( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncodingDefault(const EncodingDefault& orig);
  ~EncodingDefault();
  void operator=(const EncodingDefault& orig);
  ITEXACCESS_DEREF(EncodingDefault)

  DefaultExpression defaultExpression() const;
};


class TestStepGroupOrTestStep  : public StaticNode
{

public:
  TestStepGroupOrTestStep( NodeInfo nodeinfo);
  TestStepGroupOrTestStep(const TestStepGroupOrTestStep& orig);
  ~TestStepGroupOrTestStep();
  void operator=(const TestStepGroupOrTestStep& orig);
  ITEXACCESS_DEREF(TestStepGroupOrTestStep)

  TestStepGroup testStepGroup() const;
  TestStep testStep() const;
  Choices::Choice choice() const;
};


class WithComponents  : public ParseTreeNode
{

public:
  WithComponents( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  WithComponents(const WithComponents& orig);
  ~WithComponents();
  void operator=(const WithComponents& orig);
  ITEXACCESS_DEREF(WithComponents)

  MultipleTypeConstraints multipleTypeConstraints() const;
};


class BehaviourDescription  : public RowNode
{

public:
  BehaviourDescription( NodeInfo nodeinfo,  Table* tab);
  BehaviourDescription(const BehaviourDescription& orig);
  ~BehaviourDescription();
  void operator=(const BehaviourDescription& orig);
  ITEXACCESS_DEREF(BehaviourDescription)

  RootTree rootTree() const;
  LocalTreeList localTreeList() const;
};


class CompactTestCase  : public TableNode
{

public:
  CompactTestCase( NodeInfo nodeinfo);
  CompactTestCase(const CompactTestCase& orig);
  ~CompactTestCase();
  void operator=(const CompactTestCase& orig);
  ITEXACCESS_DEREF(CompactTestCase)

  TestCaseId testCaseId() const;
  TestPurpose testPurpose() const;
  TestStepAttachment testStepAttachment() const;
  Comment comment() const;
  SelExprId selExprId() const;
  Description description() const;

  Boolean is_present_testCaseId() const;
  Boolean is_present_testPurpose() const;
  Boolean is_present_testStepAttachment() const;
  Boolean is_present_comment() const;
  Boolean is_present_selExprId() const;
  Boolean is_present_description() const;
};


class CM_ParValue  : public RowNode
{

public:
  CM_ParValue( NodeInfo nodeinfo,  Table* tab,  Row* row);
  CM_ParValue(const CM_ParValue& orig);
  ~CM_ParValue();
  void operator=(const CM_ParValue& orig);
  ITEXACCESS_DEREF(CM_ParValue)

  CM_ParId cm_ParId() const;
  ConsValue consValue() const;
  Comment comment() const;

  Boolean is_present_cm_ParId() const;
  Boolean is_present_consValue() const;
  Boolean is_present_comment() const;
};


class TTCN_CM_Constraint  : public TableNode
{

public:
  TTCN_CM_Constraint( NodeInfo nodeinfo);
  TTCN_CM_Constraint(const TTCN_CM_Constraint& orig);
  ~TTCN_CM_Constraint();
  void operator=(const TTCN_CM_Constraint& orig);
  ITEXACCESS_DEREF(TTCN_CM_Constraint)

  ConsId consId() const;
  CM_Id cm_Id() const;
  DerivPath derivPath() const;
  Comment comment() const;
  CM_ParValues cm_ParValues() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_cm_Id() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class PDU_TypeDefs  : public StaticNode
{

public:
  PDU_TypeDefs( NodeInfo nodeinfo);
  PDU_TypeDefs(const PDU_TypeDefs& orig);
  ~PDU_TypeDefs();
  void operator=(const PDU_TypeDefs& orig);
  ITEXACCESS_DEREF(PDU_TypeDefs)

  TTCN_PDU_TypeDefs ttcn_PDU_TypeDefs() const;
  ASN1_PDU_TypeDefs asn1_PDU_TypeDefs() const;
  ASN1_PDU_TypeDefsByRef asn1_PDU_TypeDefsByRef() const;
};


class TCompDcl  : public TableNode
{

public:
  TCompDcl( NodeInfo nodeinfo);
  TCompDcl(const TCompDcl& orig);
  ~TCompDcl();
  void operator=(const TCompDcl& orig);
  ITEXACCESS_DEREF(TCompDcl)

  TCompId tcompId() const;
  TC_Role tc_Role() const;
  NumOf_PCOs numOf_PCOs() const;
  NumOf_CPs numOf_CPs() const;
  Comment comment() const;

  Boolean is_present_tcompId() const;
  Boolean is_present_tc_Role() const;
  Boolean is_present_numOf_PCOs() const;
  Boolean is_present_numOf_CPs() const;
  Boolean is_present_comment() const;
};


class TS_ConstType  : public ParseTreeNode
{

public:
  TS_ConstType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ConstType(const TS_ConstType& orig);
  ~TS_ConstType();
  void operator=(const TS_ConstType& orig);
  ITEXACCESS_DEREF(TS_ConstType)

  TTCN_Type ttcn_Type() const;
};


class ElemDcls  : public RowList
{

public:
  ElemDcls( NodeInfo nodeinfo,  Table* tab);
  ElemDcls(const ElemDcls& orig);
  ~ElemDcls();
  void operator=(const ElemDcls& orig);
  ITEXACCESS_DEREF(ElemDcls)

  ElemDcl elemDcl(int index) const;
  ElemDcl operator[](int index) const;
};


class LengthAttribute  : public ParseTreeNode
{

public:
  LengthAttribute( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LengthAttribute(const LengthAttribute& orig);
  ~LengthAttribute();
  void operator=(const LengthAttribute& orig);
  ITEXACCESS_DEREF(LengthAttribute)

  SingleLength singleLength() const;
  RangeLength rangeLength() const;
  Choices::Choice choice() const;
};


class Permutation  : public ParseTreeNode
{

public:
  Permutation( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Permutation(const Permutation& orig);
  ~Permutation();
  void operator=(const Permutation& orig);
  ITEXACCESS_DEREF(Permutation)

  ValueList valueList() const;
};


class DefaultsLibrary  : public StaticNode
{

public:
  DefaultsLibrary( NodeInfo nodeinfo);
  DefaultsLibrary(const DefaultsLibrary& orig);
  ~DefaultsLibrary();
  void operator=(const DefaultsLibrary& orig);
  ITEXACCESS_DEREF(DefaultsLibrary)

  DefaultGroupOrDefaultList defaultGroupOrDefaultList() const;
};


class DerivPath  : public ParseTreeNode
{

public:
  DerivPath( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DerivPath(const DerivPath& orig);
  ~DerivPath();
  void operator=(const DerivPath& orig);
  ITEXACCESS_DEREF(DerivPath)

  DerivationPath derivationPath() const;
};


class ImportPart  : public StaticNode
{

public:
  ImportPart( NodeInfo nodeinfo);
  ImportPart(const ImportPart& orig);
  ~ImportPart();
  void operator=(const ImportPart& orig);
  ITEXACCESS_DEREF(ImportPart)

  ImportDeclarations importDeclarations() const;
};


class PASS  : public TerminalNode
{

public:
  PASS( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PASS(const PASS& orig);
  ~PASS();
  void operator=(const PASS& orig);
  ITEXACCESS_DEREF(PASS)

};


class MTC  : public TerminalNode
{

public:
  MTC( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MTC(const MTC& orig);
  ~MTC();
  void operator=(const MTC& orig);
  ITEXACCESS_DEREF(MTC)

};


class SubtypeValueSet  : public ParseTreeNode
{

public:
  SubtypeValueSet( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SubtypeValueSet(const SubtypeValueSet& orig);
  ~SubtypeValueSet();
  void operator=(const SubtypeValueSet& orig);
  ITEXACCESS_DEREF(SubtypeValueSet)

  SingleValue singleValue() const;
  ContainedSubType containedSubType() const;
  ValueRange valueRange() const;
  PermittedAlphabet permittedAlphabet() const;
  SizeConstraint sizeConstraint() const;
  InnerTypeConstraints innerTypeConstraints() const;
  Choices::Choice choice() const;
};


class EnumeratedType  : public ParseTreeNode
{

public:
  EnumeratedType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EnumeratedType(const EnumeratedType& orig);
  ~EnumeratedType();
  void operator=(const EnumeratedType& orig);
  ITEXACCESS_DEREF(EnumeratedType)

  Enumeration enumeration() const;
};


class DefaultGroupOrDefaultList  : public StaticList
{

public:
  DefaultGroupOrDefaultList( NodeInfo nodeinfo);
  DefaultGroupOrDefaultList(const DefaultGroupOrDefaultList& orig);
  ~DefaultGroupOrDefaultList();
  void operator=(const DefaultGroupOrDefaultList& orig);
  ITEXACCESS_DEREF(DefaultGroupOrDefaultList)

  DefaultGroupOrDefault defaultGroupOrDefault(int index) const;
  DefaultGroupOrDefault operator[](int index) const;
};


class Otherwise  : public ParseTreeNode
{

public:
  Otherwise( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Otherwise(const Otherwise& orig);
  ~Otherwise();
  void operator=(const Otherwise& orig);
  ITEXACCESS_DEREF(Otherwise)

  Identifier identifier() const;

  Boolean is_present_identifier() const;
};


class LabelId  : public ParseTreeNode
{

public:
  LabelId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LabelId(const LabelId& orig);
  ~LabelId();
  void operator=(const LabelId& orig);
  ITEXACCESS_DEREF(LabelId)

  Label label() const;
};


class TTCN_CM_Constraints  : public StaticList
{

public:
  TTCN_CM_Constraints( NodeInfo nodeinfo);
  TTCN_CM_Constraints(const TTCN_CM_Constraints& orig);
  ~TTCN_CM_Constraints();
  void operator=(const TTCN_CM_Constraints& orig);
  ITEXACCESS_DEREF(TTCN_CM_Constraints)

  TTCN_CM_Constraint ttcn_CM_Constraint(int index) const;
  TTCN_CM_Constraint operator[](int index) const;
};


class ASN1_ASP_TypeDefsByRef  : public TableNode
{

public:
  ASN1_ASP_TypeDefsByRef( NodeInfo nodeinfo);
  ASN1_ASP_TypeDefsByRef(const ASN1_ASP_TypeDefsByRef& orig);
  ~ASN1_ASP_TypeDefsByRef();
  void operator=(const ASN1_ASP_TypeDefsByRef& orig);
  ITEXACCESS_DEREF(ASN1_ASP_TypeDefsByRef)

  ASN1_ASP_TypeDefByRefList asn1_ASP_TypeDefByRefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class ASP_ParDcls  : public RowList
{

public:
  ASP_ParDcls( NodeInfo nodeinfo,  Table* tab);
  ASP_ParDcls(const ASP_ParDcls& orig);
  ~ASP_ParDcls();
  void operator=(const ASP_ParDcls& orig);
  ITEXACCESS_DEREF(ASP_ParDcls)

  ASP_ParDcl asp_ParDcl(int index) const;
  ASP_ParDcl operator[](int index) const;
};


class Num_PCOs  : public ParseTreeNode
{

public:
  Num_PCOs( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Num_PCOs(const Num_PCOs& orig);
  ~Num_PCOs();
  void operator=(const Num_PCOs& orig);
  ITEXACCESS_DEREF(Num_PCOs)

  Number number() const;
};


class PreliminaryINCONC  : public TerminalNode
{

public:
  PreliminaryINCONC( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PreliminaryINCONC(const PreliminaryINCONC& orig);
  ~PreliminaryINCONC();
  void operator=(const PreliminaryINCONC& orig);
  ITEXACCESS_DEREF(PreliminaryINCONC)

};


class PreliminaryPASS  : public TerminalNode
{

public:
  PreliminaryPASS( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PreliminaryPASS(const PreliminaryPASS& orig);
  ~PreliminaryPASS();
  void operator=(const PreliminaryPASS& orig);
  ITEXACCESS_DEREF(PreliminaryPASS)

};


class ABSENT  : public TerminalNode
{

public:
  ABSENT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ABSENT(const ABSENT& orig);
  ~ABSENT();
  void operator=(const ABSENT& orig);
  ITEXACCESS_DEREF(ABSENT)

};


class Done  : public ParseTreeNode
{

public:
  Done( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Done(const Done& orig);
  ~Done();
  void operator=(const Done& orig);
  ITEXACCESS_DEREF(Done)

  TCompIdList tcompIdList() const;
};


class TC_VarDcls  : public TableNode
{

public:
  TC_VarDcls( NodeInfo nodeinfo);
  TC_VarDcls(const TC_VarDcls& orig);
  ~TC_VarDcls();
  void operator=(const TC_VarDcls& orig);
  ITEXACCESS_DEREF(TC_VarDcls)

  TC_VarDclList tc_VarDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class TS_VarValue  : public ParseTreeNode
{

public:
  TS_VarValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_VarValue(const TS_VarValue& orig);
  ~TS_VarValue();
  void operator=(const TS_VarValue& orig);
  ITEXACCESS_DEREF(TS_VarValue)

  DeclarationValue declarationValue() const;
};


class TS_ProcDescription  : public TerminalNode
{

public:
  TS_ProcDescription( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_ProcDescription(const TS_ProcDescription& orig);
  ~TS_ProcDescription();
  void operator=(const TS_ProcDescription& orig);
  ITEXACCESS_DEREF(TS_ProcDescription)

};


class EncodingDefinitions  : public TableNode
{

public:
  EncodingDefinitions( NodeInfo nodeinfo);
  EncodingDefinitions(const EncodingDefinitions& orig);
  ~EncodingDefinitions();
  void operator=(const EncodingDefinitions& orig);
  ITEXACCESS_DEREF(EncodingDefinitions)

  EncodingDefList encodingDefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class SingleTypeLength  : public ParseTreeNode
{

public:
  SingleTypeLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SingleTypeLength(const SingleTypeLength& orig);
  ~SingleTypeLength();
  void operator=(const SingleTypeLength& orig);
  ITEXACCESS_DEREF(SingleTypeLength)

  Number number() const;
};


class IA5String  : public TerminalNode
{

public:
  IA5String( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  IA5String(const IA5String& orig);
  ~IA5String();
  void operator=(const IA5String& orig);
  ITEXACCESS_DEREF(IA5String)

};


class Ostring  : public TerminalNode
{

public:
  Ostring( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Ostring(const Ostring& orig);
  ~Ostring();
  void operator=(const Ostring& orig);
  ITEXACCESS_DEREF(Ostring)

};


class RangeValueLength  : public ParseTreeNode
{

public:
  RangeValueLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RangeValueLength(const RangeValueLength& orig);
  ~RangeValueLength();
  void operator=(const RangeValueLength& orig);
  ITEXACCESS_DEREF(RangeValueLength)

  LowerValueBound lowerValueBound() const;
  UpperValueBound upperValueBound() const;
};


class Verdict  : public ParseTreeNode
{

public:
  Verdict( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Verdict(const Verdict& orig);
  ~Verdict();
  void operator=(const Verdict& orig);
  ITEXACCESS_DEREF(Verdict)

  Pass pass() const;
  Fail fail() const;
  Inconclusive inconclusive() const;
  Result result() const;
  Choices::Choice choice() const;
};


class ASN1_PDU_TypeDefsByRef  : public TableNode
{

public:
  ASN1_PDU_TypeDefsByRef( NodeInfo nodeinfo);
  ASN1_PDU_TypeDefsByRef(const ASN1_PDU_TypeDefsByRef& orig);
  ~ASN1_PDU_TypeDefsByRef();
  void operator=(const ASN1_PDU_TypeDefsByRef& orig);
  ITEXACCESS_DEREF(ASN1_PDU_TypeDefsByRef)

  ASN1_PDU_TypeDefByRefList asn1_PDU_TypeDefByRefList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class PDU_Id  : public ParseTreeNode
{

public:
  PDU_Id( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_Id(const PDU_Id& orig);
  ~PDU_Id();
  void operator=(const PDU_Id& orig);
  ITEXACCESS_DEREF(PDU_Id)

  PDU_IdAndFullId pdu_IdAndFullId() const;
};


class ComplexDefinitions  : public StaticNode
{

public:
  ComplexDefinitions( NodeInfo nodeinfo);
  ComplexDefinitions(const ComplexDefinitions& orig);
  ~ComplexDefinitions();
  void operator=(const ComplexDefinitions& orig);
  ITEXACCESS_DEREF(ComplexDefinitions)

  ASP_TypeDefs asp_TypeDefs() const;
  PDU_TypeDefs pdu_TypeDefs() const;
  CM_TypeDefs cm_TypeDefs() const;
  AliasDefs aliasDefs() const;
};


class SelectExprDefList  : public StaticList
{

public:
  SelectExprDefList( NodeInfo nodeinfo);
  SelectExprDefList(const SelectExprDefList& orig);
  ~SelectExprDefList();
  void operator=(const SelectExprDefList& orig);
  ITEXACCESS_DEREF(SelectExprDefList)

  SelectExprDef selectExprDef(int index) const;
  SelectExprDef operator[](int index) const;
};


class ASN1_TypeDefinition  : public ParseTreeNode
{

public:
  ASN1_TypeDefinition( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_TypeDefinition(const ASN1_TypeDefinition& orig);
  ~ASN1_TypeDefinition();
  void operator=(const ASN1_TypeDefinition& orig);
  ITEXACCESS_DEREF(ASN1_TypeDefinition)

  ASN1_TypeAndLocalTypes asn1_TypeAndLocalTypes() const;
};


class SubSet  : public ParseTreeNode
{

public:
  SubSet( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SubSet(const SubSet& orig);
  ~SubSet();
  void operator=(const SubSet& orig);
  ITEXACCESS_DEREF(SubSet)

  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class Complement  : public ParseTreeNode
{

public:
  Complement( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Complement(const Complement& orig);
  ~Complement();
  void operator=(const Complement& orig);
  ITEXACCESS_DEREF(Complement)

  ValueList valueList() const;
};


class VerdictId  : public ParseTreeNode
{

public:
  VerdictId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  VerdictId(const VerdictId& orig);
  ~VerdictId();
  void operator=(const VerdictId& orig);
  ITEXACCESS_DEREF(VerdictId)

  Verdict verdict() const;
};


class DefaultsRef  : public ParseTreeNode
{

public:
  DefaultsRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultsRef(const DefaultsRef& orig);
  ~DefaultsRef();
  void operator=(const DefaultsRef& orig);
  ITEXACCESS_DEREF(DefaultsRef)

  DefaultRefList defaultRefList() const;
};


class Bstring  : public TerminalNode
{

public:
  Bstring( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Bstring(const Bstring& orig);
  ~Bstring();
  void operator=(const Bstring& orig);
  ITEXACCESS_DEREF(Bstring)

};


class TagAttributes  : public ParseTreeNode
{

public:
  TagAttributes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TagAttributes(const TagAttributes& orig);
  ~TagAttributes();
  void operator=(const TagAttributes& orig);
  ITEXACCESS_DEREF(TagAttributes)

  AIMPLICIT Aimplicit() const;
  AEXPLICIT Aexplicit() const;
  Choices::Choice choice() const;
};


class ActualParList  : public ParseTreeList
{

public:
  ActualParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ActualParList(const ActualParList& orig);
  ~ActualParList();
  void operator=(const ActualParList& orig);
  ITEXACCESS_DEREF(ActualParList)

  ConstraintValueAndAttributes constraintValueAndAttributes(int index) const;
  ConstraintValueAndAttributes operator[](int index) const;
};


class ValueLength  : public ParseTreeNode
{

public:
  ValueLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueLength(const ValueLength& orig);
  ~ValueLength();
  void operator=(const ValueLength& orig);
  ITEXACCESS_DEREF(ValueLength)

  SingleValueLength singleValueLength() const;
  RangeValueLength rangeValueLength() const;
  Choices::Choice choice() const;
};


class TestStepGroupOrTestStepList  : public StaticList
{

public:
  TestStepGroupOrTestStepList( NodeInfo nodeinfo);
  TestStepGroupOrTestStepList(const TestStepGroupOrTestStepList& orig);
  ~TestStepGroupOrTestStepList();
  void operator=(const TestStepGroupOrTestStepList& orig);
  ITEXACCESS_DEREF(TestStepGroupOrTestStepList)

  TestStepGroupOrTestStep testStepGroupOrTestStep(int index) const;
  TestStepGroupOrTestStep operator[](int index) const;
};


class Cref  : public ParseTreeNode
{

public:
  Cref( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Cref(const Cref& orig);
  ~Cref();
  void operator=(const Cref& orig);
  ITEXACCESS_DEREF(Cref)

  ConstraintReference constraintReference() const;
};


class TimerOps  : public ParseTreeList
{

public:
  TimerOps( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TimerOps(const TimerOps& orig);
  ~TimerOps();
  void operator=(const TimerOps& orig);
  ITEXACCESS_DEREF(TimerOps)

  TimerOp timerOp(int index) const;
  TimerOp operator[](int index) const;
};


class TestCase  : public TableNode
{

public:
  TestCase( NodeInfo nodeinfo);
  TestCase(const TestCase& orig);
  ~TestCase();
  void operator=(const TestCase& orig);
  ITEXACCESS_DEREF(TestCase)

  TestCaseId testCaseId() const;
  TestGroupRef testGroupRef() const;
  TestPurpose testPurpose() const;
  Configuration configuration() const;
  DefaultsRef defaultsRef() const;
  Comment comment() const;
  SelExprId selExprId() const;
  Description description() const;
  BehaviourDescription behaviourDescription() const;
  DetailedComment detailedComment() const;

  Boolean is_present_testCaseId() const;
  Boolean is_present_testGroupRef() const;
  Boolean is_present_testPurpose() const;
  Boolean is_present_configuration() const;
  Boolean is_present_defaultsRef() const;
  Boolean is_present_comment() const;
  Boolean is_present_selExprId() const;
  Boolean is_present_description() const;
  Boolean is_present_detailedComment() const;
};


class ASN1_TypeConstraints  : public StaticList
{

public:
  ASN1_TypeConstraints( NodeInfo nodeinfo);
  ASN1_TypeConstraints(const ASN1_TypeConstraints& orig);
  ~ASN1_TypeConstraints();
  void operator=(const ASN1_TypeConstraints& orig);
  ITEXACCESS_DEREF(ASN1_TypeConstraints)

  ASN1_TypeConstraint asn1_TypeConstraint(int index) const;
  ASN1_TypeConstraint operator[](int index) const;
};


class CM_ParDcl  : public RowNode
{

public:
  CM_ParDcl( NodeInfo nodeinfo,  Table* tab,  Row* row);
  CM_ParDcl(const CM_ParDcl& orig);
  ~CM_ParDcl();
  void operator=(const CM_ParDcl& orig);
  ITEXACCESS_DEREF(CM_ParDcl)

  CM_ParId cm_ParId() const;
  CM_ParType cm_ParType() const;
  Comment comment() const;

  Boolean is_present_cm_ParId() const;
  Boolean is_present_cm_ParType() const;
  Boolean is_present_comment() const;
};


class ASN1_Type  : public ParseTreeNode
{

public:
  ASN1_Type( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_Type(const ASN1_Type& orig);
  ~ASN1_Type();
  void operator=(const ASN1_Type& orig);
  ITEXACCESS_DEREF(ASN1_Type)

  BuiltinType builtinType() const;
  DefinedType definedType() const;
  SubType subType() const;
  Choices::Choice choice() const;
};


class TimerValue  : public ParseTreeNode
{

public:
  TimerValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TimerValue(const TimerValue& orig);
  ~TimerValue();
  void operator=(const TimerValue& orig);
  ITEXACCESS_DEREF(TimerValue)

  Expression expression() const;
};


class PDU_FieldValue  : public RowNode
{

public:
  PDU_FieldValue( NodeInfo nodeinfo,  Table* tab,  Row* row);
  PDU_FieldValue(const PDU_FieldValue& orig);
  ~PDU_FieldValue();
  void operator=(const PDU_FieldValue& orig);
  ITEXACCESS_DEREF(PDU_FieldValue)

  PDU_FieldId pdu_FieldId() const;
  ConsValue consValue() const;
  PDU_FieldEncoding pdu_FieldEncoding() const;
  Comment comment() const;

  Boolean is_present_pdu_FieldId() const;
  Boolean is_present_consValue() const;
  Boolean is_present_pdu_FieldEncoding() const;
  Boolean is_present_comment() const;
};


class TS_ConstRef  : public TableNode
{

public:
  TS_ConstRef( NodeInfo nodeinfo);
  TS_ConstRef(const TS_ConstRef& orig);
  ~TS_ConstRef();
  void operator=(const TS_ConstRef& orig);
  ITEXACCESS_DEREF(TS_ConstRef)

  TS_ConstId ts_ConstId() const;
  TS_ConstType ts_ConstType() const;
  ASN1_ValueReference asn1_ValueReference() const;
  ASN1_ModuleId asn1_ModuleId() const;
  Comment comment() const;
  TS_ConstValue ts_ConstValue() const;

  Boolean is_present_ts_ConstId() const;
  Boolean is_present_ts_ConstType() const;
  Boolean is_present_asn1_ValueReference() const;
  Boolean is_present_asn1_ModuleId() const;
  Boolean is_present_comment() const;
  Boolean is_present_ts_ConstValue() const;
};


class EXTERNAL  : public TerminalNode
{

public:
  EXTERNAL( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EXTERNAL(const EXTERNAL& orig);
  ~EXTERNAL();
  void operator=(const EXTERNAL& orig);
  ITEXACCESS_DEREF(EXTERNAL)

};


class Indentation  : public ParseTreeRowNode
{

public:
  Indentation( NodeInfo nodeinfo,  Table* tab,  Row* row,  Field* field,  PT* pt);
  Indentation(const Indentation& orig);
  ~Indentation();
  void operator=(const Indentation& orig);
  ITEXACCESS_DEREF(Indentation)

  Number number() const;
};


class TypeConstraints  : public ParseTreeNode
{

public:
  TypeConstraints( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeConstraints(const TypeConstraints& orig);
  ~TypeConstraints();
  void operator=(const TypeConstraints& orig);
  ITEXACCESS_DEREF(TypeConstraints)

  NamedConstraintList namedConstraintList() const;
};


class LiteralValue  : public ParseTreeNode
{

public:
  LiteralValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LiteralValue(const LiteralValue& orig);
  ~LiteralValue();
  void operator=(const LiteralValue& orig);
  ITEXACCESS_DEREF(LiteralValue)

  Number number() const;
  BooleanValue booleanValue() const;
  Bstring bstring() const;
  Hstring hstring() const;
  Ostring ostring() const;
  Cstring cstring() const;
  R_Value r_Value() const;
  Choices::Choice choice() const;
};


class StatementLine  : public ParseTreeNode
{

public:
  StatementLine( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  StatementLine(const StatementLine& orig);
  ~StatementLine();
  void operator=(const StatementLine& orig);
  ITEXACCESS_DEREF(StatementLine)

  EventStatement eventStatement() const;
  Construct construct() const;
  ImplicitSend implicitSend() const;
  Choices::Choice choice() const;
};


class SO_TestStepRef  : public TerminalNode
{

public:
  SO_TestStepRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_TestStepRef(const SO_TestStepRef& orig);
  ~SO_TestStepRef();
  void operator=(const SO_TestStepRef& orig);
  ITEXACCESS_DEREF(SO_TestStepRef)

};


class HEXSTRING  : public TerminalNode
{

public:
  HEXSTRING( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  HEXSTRING(const HEXSTRING& orig);
  ~HEXSTRING();
  void operator=(const HEXSTRING& orig);
  ITEXACCESS_DEREF(HEXSTRING)

};


class NamedTypeAndAttributes  : public ParseTreeNode
{

public:
  NamedTypeAndAttributes( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  NamedTypeAndAttributes(const NamedTypeAndAttributes& orig);
  ~NamedTypeAndAttributes();
  void operator=(const NamedTypeAndAttributes& orig);
  ITEXACCESS_DEREF(NamedTypeAndAttributes)

  NamedTypeOrSelection namedTypeOrSelection() const;
  NamedTypeAttribute namedTypeAttribute() const;

  Boolean is_present_namedTypeAttribute() const;
};


class ConstraintReference  : public ParseTreeNode
{

public:
  ConstraintReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConstraintReference(const ConstraintReference& orig);
  ~ConstraintReference();
  void operator=(const ConstraintReference& orig);
  ITEXACCESS_DEREF(ConstraintReference)

  ConsRef consRef() const;
  Identifier formalParIdentifier() const;
  Choices::Choice choice() const;
};


class ASN1_PDU_Constraints  : public StaticList
{

public:
  ASN1_PDU_Constraints( NodeInfo nodeinfo);
  ASN1_PDU_Constraints(const ASN1_PDU_Constraints& orig);
  ~ASN1_PDU_Constraints();
  void operator=(const ASN1_PDU_Constraints& orig);
  ITEXACCESS_DEREF(ASN1_PDU_Constraints)

  ASN1_PDU_Constraint asn1_PDU_Constraint(int index) const;
  ASN1_PDU_Constraint operator[](int index) const;
};


class ConsIdAndParList  : public ParseTreeNode
{

public:
  ConsIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConsIdAndParList(const ConsIdAndParList& orig);
  ~ConsIdAndParList();
  void operator=(const ConsIdAndParList& orig);
  ITEXACCESS_DEREF(ConsIdAndParList)

  Identifier constraintIdentifier() const;
  FormalParList formalParList() const;
};


class SO_Objective  : public TerminalNode
{

public:
  SO_Objective( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_Objective(const SO_Objective& orig);
  ~SO_Objective();
  void operator=(const SO_Objective& orig);
  ITEXACCESS_DEREF(SO_Objective)

};


class ParamAndSelection  : public StaticNode
{

public:
  ParamAndSelection( NodeInfo nodeinfo);
  ParamAndSelection(const ParamAndSelection& orig);
  ~ParamAndSelection();
  void operator=(const ParamAndSelection& orig);
  ITEXACCESS_DEREF(ParamAndSelection)

  TS_ParDcls ts_ParDcls() const;
  SelectExprDefs selectExprDefs() const;
};


class Receive  : public ParseTreeNode
{

public:
  Receive( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Receive(const Receive& orig);
  ~Receive();
  void operator=(const Receive& orig);
  ITEXACCESS_DEREF(Receive)

  Identifier identifier1() const;
  Identifier identifier2() const;

  Boolean is_present_identifier1() const;
};


class ASN1_CM_Constraints  : public StaticList
{

public:
  ASN1_CM_Constraints( NodeInfo nodeinfo);
  ASN1_CM_Constraints(const ASN1_CM_Constraints& orig);
  ~ASN1_CM_Constraints();
  void operator=(const ASN1_CM_Constraints& orig);
  ITEXACCESS_DEREF(ASN1_CM_Constraints)

  ASN1_CM_Constraint asn1_CM_Constraint(int index) const;
  ASN1_CM_Constraint operator[](int index) const;
};


class PCO_Type  : public ParseTreeNode
{

public:
  PCO_Type( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PCO_Type(const PCO_Type& orig);
  ~PCO_Type();
  void operator=(const PCO_Type& orig);
  ITEXACCESS_DEREF(PCO_Type)

  Identifier pco_TypeIdentifier() const;
};


class TComp_Role  : public ParseTreeNode
{

public:
  TComp_Role( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TComp_Role(const TComp_Role& orig);
  ~TComp_Role();
  void operator=(const TComp_Role& orig);
  ITEXACCESS_DEREF(TComp_Role)

  MTC mtc() const;
  PTC ptc() const;
  Choices::Choice choice() const;
};


class Definitions  : public StaticNode
{

public:
  Definitions( NodeInfo nodeinfo);
  Definitions(const Definitions& orig);
  ~Definitions();
  void operator=(const Definitions& orig);
  ITEXACCESS_DEREF(Definitions)

  TS_TypeDefs ts_TypeDefs() const;
  EncodingDefs encodingDefs() const;
  TS_OpDefs ts_OpDefs() const;
  TS_ProcDefs ts_ProcDefs() const;
};


class Seconds  : public TerminalNode
{

public:
  Seconds( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Seconds(const Seconds& orig);
  ~Seconds();
  void operator=(const Seconds& orig);
  ITEXACCESS_DEREF(Seconds)

};


class ValueConstraint  : public ParseTreeNode
{

public:
  ValueConstraint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ValueConstraint(const ValueConstraint& orig);
  ~ValueConstraint();
  void operator=(const ValueConstraint& orig);
  ITEXACCESS_DEREF(ValueConstraint)

  SubTypeSpec subTypeSpec() const;
};


class DataObjectReference  : public ParseTreeNode
{

public:
  DataObjectReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DataObjectReference(const DataObjectReference& orig);
  ~DataObjectReference();
  void operator=(const DataObjectReference& orig);
  ITEXACCESS_DEREF(DataObjectReference)

  Identifier dataObjectIdentifier() const;
  ComponentReferenceList componentReferenceList() const;
};


class AliasDef  : public TableNode
{

public:
  AliasDef( NodeInfo nodeinfo);
  AliasDef(const AliasDef& orig);
  ~AliasDef();
  void operator=(const AliasDef& orig);
  ITEXACCESS_DEREF(AliasDef)

  AliasId aliasId() const;
  ExpandedId expandedId() const;
  Comment comment() const;

  Boolean is_present_aliasId() const;
  Boolean is_present_expandedId() const;
  Boolean is_present_comment() const;
};


class AIMPLICIT  : public TerminalNode
{

public:
  AIMPLICIT( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  AIMPLICIT(const AIMPLICIT& orig);
  ~AIMPLICIT();
  void operator=(const AIMPLICIT& orig);
  ITEXACCESS_DEREF(AIMPLICIT)

};


class BitStringValue  : public ParseTreeNode
{

public:
  BitStringValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BitStringValue(const BitStringValue& orig);
  ~BitStringValue();
  void operator=(const BitStringValue& orig);
  ITEXACCESS_DEREF(BitStringValue)

  IdentifierList identifierList() const;
};


class Value  : public ParseTreeNode
{

public:
  Value( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Value(const Value& orig);
  ~Value();
  void operator=(const Value& orig);
  ITEXACCESS_DEREF(Value)

  LiteralValue literalValue() const;
  ASN1_Value asn1_Value() const;
  Choices::Choice choice() const;
};


class RelOp  : public ParseTreeNode
{

public:
  RelOp( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RelOp(const RelOp& orig);
  ~RelOp();
  void operator=(const RelOp& orig);
  ITEXACCESS_DEREF(RelOp)

  Equal equal() const;
  Less less() const;
  Greater greater() const;
  NotEqual notEqual() const;
  GreaterOrEqual greaterOrEqual() const;
  LessOrEqual lessOrEqual() const;
  Choices::Choice choice() const;
};


class RelExpression  : public ParseTreeNode
{

public:
  RelExpression( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RelExpression(const RelExpression& orig);
  ~RelExpression();
  void operator=(const RelExpression& orig);
  ITEXACCESS_DEREF(RelExpression)

  SimpleExpression simpleExpression1() const;
  RelOp relOp() const;
  SimpleExpression simpleExpression2() const;
};


class LineNumber  : public ParseTreeNode
{

public:
  LineNumber( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LineNumber(const LineNumber& orig);
  ~LineNumber();
  void operator=(const LineNumber& orig);
  ITEXACCESS_DEREF(LineNumber)

  Number number() const;
};


class Number  : public TerminalNode
{

public:
  Number( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Number(const Number& orig);
  ~Number();
  void operator=(const Number& orig);
  ITEXACCESS_DEREF(Number)

};


class TypeAndRestriction  : public ParseTreeNode
{

public:
  TypeAndRestriction( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TypeAndRestriction(const TypeAndRestriction& orig);
  ~TypeAndRestriction();
  void operator=(const TypeAndRestriction& orig);
  ITEXACCESS_DEREF(TypeAndRestriction)

  TTCN_Type ttcn_Type() const;
  Restriction restriction() const;

  Boolean is_present_restriction() const;
};


class TS_OpIdAndParList  : public ParseTreeNode
{

public:
  TS_OpIdAndParList( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TS_OpIdAndParList(const TS_OpIdAndParList& orig);
  ~TS_OpIdAndParList();
  void operator=(const TS_OpIdAndParList& orig);
  ITEXACCESS_DEREF(TS_OpIdAndParList)

  Identifier ts_OpIdentifier() const;
  FormalParList formalParList() const;
};


class LowerEndpoint  : public ParseTreeNode
{

public:
  LowerEndpoint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  LowerEndpoint(const LowerEndpoint& orig);
  ~LowerEndpoint();
  void operator=(const LowerEndpoint& orig);
  ITEXACCESS_DEREF(LowerEndpoint)

  LowerEndValue lowerEndValue() const;
  INCLUSIVE inclusive() const;

  Boolean is_present_inclusive() const;
};


class ASN1_Value  : public ParseTreeNode
{

public:
  ASN1_Value( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ASN1_Value(const ASN1_Value& orig);
  ~ASN1_Value();
  void operator=(const ASN1_Value& orig);
  ITEXACCESS_DEREF(ASN1_Value)

  BitStringValue bitStringValue() const;
  NullValue nullValue() const;
  SequenceValue sequenceValue() const;
  SequenceOfValue sequenceOfValue() const;
  SetValue setValue() const;
  SetOfValue setOfValue() const;
  ChoiceValue choiceValue() const;
  SelectionValue selectionValue() const;
  AnyValue anyValue() const;
  ObjectIdentifierValue objectIdentifierValue() const;
  RealValue realValue() const;
  Choices::Choice choice() const;
};


class CancelTimer  : public ParseTreeNode
{

public:
  CancelTimer( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CancelTimer(const CancelTimer& orig);
  ~CancelTimer();
  void operator=(const CancelTimer& orig);
  ITEXACCESS_DEREF(CancelTimer)

  Identifier timerIdentifier() const;

  Boolean is_present_timerIdentifier() const;
};


class ImportDeclarations  : public StaticList
{

public:
  ImportDeclarations( NodeInfo nodeinfo);
  ImportDeclarations(const ImportDeclarations& orig);
  ~ImportDeclarations();
  void operator=(const ImportDeclarations& orig);
  ITEXACCESS_DEREF(ImportDeclarations)

  Imports imports(int index) const;
  Imports operator[](int index) const;
};


class BOOLEAN  : public TerminalNode
{

public:
  BOOLEAN( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BOOLEAN(const BOOLEAN& orig);
  ~BOOLEAN();
  void operator=(const BOOLEAN& orig);
  ITEXACCESS_DEREF(BOOLEAN)

};


class Replace  : public ParseTreeNode
{

public:
  Replace( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Replace(const Replace& orig);
  ~Replace();
  void operator=(const Replace& orig);
  ITEXACCESS_DEREF(Replace)

  ReferenceList referenceList() const;
  ConstraintValueAndAttributes constraintValueAndAttributes() const;
};


class TCompConfigInfo  : public RowNode
{

public:
  TCompConfigInfo( NodeInfo nodeinfo,  Table* tab,  Row* row);
  TCompConfigInfo(const TCompConfigInfo& orig);
  ~TCompConfigInfo();
  void operator=(const TCompConfigInfo& orig);
  ITEXACCESS_DEREF(TCompConfigInfo)

  TCompUsed tcompUsed() const;
  PCOs_Used pcos_Used() const;
  CPs_Used cps_Used() const;
  Comment comment() const;

  Boolean is_present_tcompUsed() const;
  Boolean is_present_pcos_Used() const;
  Boolean is_present_cps_Used() const;
  Boolean is_present_comment() const;
};


class SO_CaseIndex  : public RowNode
{

public:
  SO_CaseIndex( NodeInfo nodeinfo,  Table* tab,  Row* row);
  SO_CaseIndex(const SO_CaseIndex& orig);
  ~SO_CaseIndex();
  void operator=(const SO_CaseIndex& orig);
  ITEXACCESS_DEREF(SO_CaseIndex)

  SO_TestGroupRef SO_testGroupRef() const;
  SO_TestCaseId SO_testCaseId() const;
  SO_SelExprId SO_selExprId() const;
  SO_Description SO_description() const;

  Boolean is_present_SO_testGroupRef() const;
  Boolean is_present_SO_testCaseId() const;
  Boolean is_present_SO_selExprId() const;
  Boolean is_present_SO_description() const;
};


class TS_OpDef  : public TableNode
{

public:
  TS_OpDef( NodeInfo nodeinfo);
  TS_OpDef(const TS_OpDef& orig);
  ~TS_OpDef();
  void operator=(const TS_OpDef& orig);
  ITEXACCESS_DEREF(TS_OpDef)

  TS_OpId ts_OpId() const;
  TS_OpResult ts_OpResult() const;
  Comment comment() const;
  TS_OpDescription ts_OpDescription() const;
  DetailedComment detailedComment() const;

  Boolean is_present_ts_OpId() const;
  Boolean is_present_ts_OpResult() const;
  Boolean is_present_comment() const;
  Boolean is_present_ts_OpDescription() const;
  Boolean is_present_detailedComment() const;
};


class ConstraintValue  : public ParseTreeNode
{

public:
  ConstraintValue( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  ConstraintValue(const ConstraintValue& orig);
  ~ConstraintValue();
  void operator=(const ConstraintValue& orig);
  ITEXACCESS_DEREF(ConstraintValue)

  ConstraintExpression constraintExpression() const;
  MatchingSymbol matchingSymbol() const;
  ConsRef consRef() const;
  Choices::Choice choice() const;
};


class SO_StructureAndObjective  : public RowNode
{

public:
  SO_StructureAndObjective( NodeInfo nodeinfo,  Table* tab,  Row* row);
  SO_StructureAndObjective(const SO_StructureAndObjective& orig);
  ~SO_StructureAndObjective();
  void operator=(const SO_StructureAndObjective& orig);
  ITEXACCESS_DEREF(SO_StructureAndObjective)

  SO_TestGroupRef SO_testGroupRef() const;
  SO_SelExprId SO_selExprId() const;
  SO_Objective SO_objective() const;

  Boolean is_present_SO_testGroupRef() const;
  Boolean is_present_SO_selExprId() const;
  Boolean is_present_SO_objective() const;
};


class PDU_FieldEncodingCall  : public ParseTreeNode
{

public:
  PDU_FieldEncodingCall( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PDU_FieldEncodingCall(const PDU_FieldEncodingCall& orig);
  ~PDU_FieldEncodingCall();
  void operator=(const PDU_FieldEncodingCall& orig);
  ITEXACCESS_DEREF(PDU_FieldEncodingCall)

  EncVariationCall encVariationCall() const;
  InvalidFieldEncodingCall invalidFieldEncodingCall() const;
  Choices::Choice choice() const;
};


class FullSpecification  : public ParseTreeNode
{

public:
  FullSpecification( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  FullSpecification(const FullSpecification& orig);
  ~FullSpecification();
  void operator=(const FullSpecification& orig);
  ITEXACCESS_DEREF(FullSpecification)

  TypeConstraints typeConstraints() const;
};


class UpperEndpoint  : public ParseTreeNode
{

public:
  UpperEndpoint( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  UpperEndpoint(const UpperEndpoint& orig);
  ~UpperEndpoint();
  void operator=(const UpperEndpoint& orig);
  ITEXACCESS_DEREF(UpperEndpoint)

  UpperEndValue upperEndValue() const;
  INCLUSIVE inclusive() const;

  Boolean is_present_inclusive() const;
};


class PermittedAlphabet  : public ParseTreeNode
{

public:
  PermittedAlphabet( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  PermittedAlphabet(const PermittedAlphabet& orig);
  ~PermittedAlphabet();
  void operator=(const PermittedAlphabet& orig);
  ITEXACCESS_DEREF(PermittedAlphabet)

  SubTypeSpec subTypeSpec() const;
};


class BitStringType  : public ParseTreeNode
{

public:
  BitStringType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  BitStringType(const BitStringType& orig);
  ~BitStringType();
  void operator=(const BitStringType& orig);
  ITEXACCESS_DEREF(BitStringType)

  NamedBitList namedBitList() const;
};


class TreeReference  : public ParseTreeNode
{

public:
  TreeReference( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  TreeReference(const TreeReference& orig);
  ~TreeReference();
  void operator=(const TreeReference& orig);
  ITEXACCESS_DEREF(TreeReference)

  Identifier identifier() const;
};


class MicroSeconds  : public TerminalNode
{

public:
  MicroSeconds( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MicroSeconds(const MicroSeconds& orig);
  ~MicroSeconds();
  void operator=(const MicroSeconds& orig);
  ITEXACCESS_DEREF(MicroSeconds)

};


class Fail  : public ParseTreeNode
{

public:
  Fail( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Fail(const Fail& orig);
  ~Fail();
  void operator=(const Fail& orig);
  ITEXACCESS_DEREF(Fail)

  FAIL fail() const;
  PreliminaryFAIL preliminaryFAIL() const;
  Choices::Choice choice() const;
};


class StructTypeConstraint  : public TableNode
{

public:
  StructTypeConstraint( NodeInfo nodeinfo);
  StructTypeConstraint(const StructTypeConstraint& orig);
  ~StructTypeConstraint();
  void operator=(const StructTypeConstraint& orig);
  ITEXACCESS_DEREF(StructTypeConstraint)

  ConsId consId() const;
  StructId structId() const;
  DerivPath derivPath() const;
  EncVariationId encVariationId() const;
  Comment comment() const;
  ElemValues elemValues() const;
  DetailedComment detailedComment() const;

  Boolean is_present_consId() const;
  Boolean is_present_structId() const;
  Boolean is_present_derivPath() const;
  Boolean is_present_encVariationId() const;
  Boolean is_present_comment() const;
  Boolean is_present_detailedComment() const;
};


class ASN1_ASP_TypeDefByRef  : public TableNode
{

public:
  ASN1_ASP_TypeDefByRef( NodeInfo nodeinfo);
  ASN1_ASP_TypeDefByRef(const ASN1_ASP_TypeDefByRef& orig);
  ~ASN1_ASP_TypeDefByRef();
  void operator=(const ASN1_ASP_TypeDefByRef& orig);
  ITEXACCESS_DEREF(ASN1_ASP_TypeDefByRef)

  ASP_Id asp_Id() const;
  PCO_Type pco_Type() const;
  ASN1_TypeReference asn1_TypeReference() const;
  ASN1_ModuleId asn1_ModuleId() const;
  Comment comment() const;
  ASN1_TypeDefinition asn1_TypeDefinition() const;

  Boolean is_present_asp_Id() const;
  Boolean is_present_pco_Type() const;
  Boolean is_present_asn1_TypeReference() const;
  Boolean is_present_asn1_ModuleId() const;
  Boolean is_present_comment() const;
  Boolean is_present_asn1_TypeDefinition() const;
};


class Restriction  : public ParseTreeNode
{

public:
  Restriction( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Restriction(const Restriction& orig);
  ~Restriction();
  void operator=(const Restriction& orig);
  ITEXACCESS_DEREF(Restriction)

  LengthRestriction lengthRestriction() const;
  IntegerRange integerRange() const;
  SimpleValueList simpleValueList() const;
  Choices::Choice choice() const;
};


class EncodingRef  : public ParseTreeNode
{

public:
  EncodingRef( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  EncodingRef(const EncodingRef& orig);
  ~EncodingRef();
  void operator=(const EncodingRef& orig);
  ITEXACCESS_DEREF(EncodingRef)

  EncodingReference encodingReference() const;
};


class SO_DefIndex  : public RowNode
{

public:
  SO_DefIndex( NodeInfo nodeinfo,  Table* tab,  Row* row);
  SO_DefIndex(const SO_DefIndex& orig);
  ~SO_DefIndex();
  void operator=(const SO_DefIndex& orig);
  ITEXACCESS_DEREF(SO_DefIndex)

  SO_DefaultRef SO_defaultRef() const;
  SO_DefaultId SO_defaultId() const;
  SO_Description SO_description() const;

  Boolean is_present_SO_defaultRef() const;
  Boolean is_present_SO_defaultId() const;
  Boolean is_present_SO_description() const;
};


class Construct  : public ParseTreeNode
{

public:
  Construct( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Construct(const Construct& orig);
  ~Construct();
  void operator=(const Construct& orig);
  ITEXACCESS_DEREF(Construct)

  GoTo goTo() const;
  Attach attach() const;
  Repeat repeat() const;
  RETURN_ return_() const;
  Activate activate() const;
  Create create() const;
  Choices::Choice choice() const;
};


class Unit  : public ParseTreeNode
{

public:
  Unit( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Unit(const Unit& orig);
  ~Unit();
  void operator=(const Unit& orig);
  ITEXACCESS_DEREF(Unit)

  TimeUnit timeUnit() const;
};


class TS_ConstDcls  : public TableNode
{

public:
  TS_ConstDcls( NodeInfo nodeinfo);
  TS_ConstDcls(const TS_ConstDcls& orig);
  ~TS_ConstDcls();
  void operator=(const TS_ConstDcls& orig);
  ITEXACCESS_DEREF(TS_ConstDcls)

  TS_ConstDclList ts_ConstDclList() const;
  DetailedComment detailedComment() const;

  Boolean is_present_detailedComment() const;
};


class MilliSeconds  : public TerminalNode
{

public:
  MilliSeconds( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  MilliSeconds(const MilliSeconds& orig);
  ~MilliSeconds();
  void operator=(const MilliSeconds& orig);
  ITEXACCESS_DEREF(MilliSeconds)

};


class CP  : public TerminalNode
{

public:
  CP( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  CP(const CP& orig);
  ~CP();
  void operator=(const CP& orig);
  ITEXACCESS_DEREF(CP)

};


class TTCN_PDU_TypeDefs  : public StaticList
{

public:
  TTCN_PDU_TypeDefs( NodeInfo nodeinfo);
  TTCN_PDU_TypeDefs(const TTCN_PDU_TypeDefs& orig);
  ~TTCN_PDU_TypeDefs();
  void operator=(const TTCN_PDU_TypeDefs& orig);
  ITEXACCESS_DEREF(TTCN_PDU_TypeDefs)

  TTCN_PDU_TypeDef ttcn_PDU_TypeDef(int index) const;
  TTCN_PDU_TypeDef operator[](int index) const;
};


class PCO_TypeDclList  : public StaticList
{

public:
  PCO_TypeDclList( NodeInfo nodeinfo);
  PCO_TypeDclList(const PCO_TypeDclList& orig);
  ~PCO_TypeDclList();
  void operator=(const PCO_TypeDclList& orig);
  ITEXACCESS_DEREF(PCO_TypeDclList)

  PCO_TypeDcl pco_TypeDcl(int index) const;
  PCO_TypeDcl operator[](int index) const;
};


class EncodingVariationList  : public StaticList
{

public:
  EncodingVariationList( NodeInfo nodeinfo);
  EncodingVariationList(const EncodingVariationList& orig);
  ~EncodingVariationList();
  void operator=(const EncodingVariationList& orig);
  ITEXACCESS_DEREF(EncodingVariationList)

  EncodingVariation encodingVariation(int index) const;
  EncodingVariation operator[](int index) const;
};


class INCLUSIVE  : public TerminalNode
{

public:
  INCLUSIVE( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  INCLUSIVE(const INCLUSIVE& orig);
  ~INCLUSIVE();
  void operator=(const INCLUSIVE& orig);
  ITEXACCESS_DEREF(INCLUSIVE)

};


class SetType  : public ParseTreeNode
{

public:
  SetType( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SetType(const SetType& orig);
  ~SetType();
  void operator=(const SetType& orig);
  ITEXACCESS_DEREF(SetType)

  ElementTypeList elementTypeList() const;
};


class SO_SelExprId  : public TerminalNode
{

public:
  SO_SelExprId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  SO_SelExprId(const SO_SelExprId& orig);
  ~SO_SelExprId();
  void operator=(const SO_SelExprId& orig);
  ITEXACCESS_DEREF(SO_SelExprId)

};


class Bound  : public ParseTreeNode
{

public:
  Bound( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  Bound(const Bound& orig);
  ~Bound();
  void operator=(const Bound& orig);
  ITEXACCESS_DEREF(Bound)

  Number number() const;
  Identifier identifier() const;
  Choices::Choice choice() const;
};


class GeneralizedTime  : public TerminalNode
{

public:
  GeneralizedTime( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  GeneralizedTime(const GeneralizedTime& orig);
  ~GeneralizedTime();
  void operator=(const GeneralizedTime& orig);
  ITEXACCESS_DEREF(GeneralizedTime)

};


class DefaultGroupId  : public ParseTreeNode
{

public:
  DefaultGroupId( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  DefaultGroupId(const DefaultGroupId& orig);
  ~DefaultGroupId();
  void operator=(const DefaultGroupId& orig);
  ITEXACCESS_DEREF(DefaultGroupId)

  Identifier defaultGroupIdentifier() const;
};


class RangeLength  : public ParseTreeNode
{

public:
  RangeLength( NodeInfo nodeinfo,  Table* tab,  Field* field,  PT* pt);
  RangeLength(const RangeLength& orig);
  ~RangeLength();
  void operator=(const RangeLength& orig);
  ITEXACCESS_DEREF(RangeLength)

  LowerBound lowerBound() const;
  UpperBound upperBound() const;
};


class SimpleTypeDefList  : public StaticList
{

public:
  SimpleTypeDefList( NodeInfo nodeinfo);
  SimpleTypeDefList(const SimpleTypeDefList& orig);
  ~SimpleTypeDefList();
  void operator=(const SimpleTypeDefList& orig);
  ITEXACCESS_DEREF(SimpleTypeDefList)

  SimpleTypeDef simpleTypeDef(int index) const;
  SimpleTypeDef operator[](int index) const;
};


class SO_CaseIndexList  : public RowList
{

public:
  SO_CaseIndexList( NodeInfo nodeinfo,  Table* tab);
  SO_CaseIndexList(const SO_CaseIndexList& orig);
  ~SO_CaseIndexList();
  void operator=(const SO_CaseIndexList& orig);
  ITEXACCESS_DEREF(SO_CaseIndexList)

  SO_CaseIndex SO_caseIndex(int index) const;
  SO_CaseIndex operator[](int index) const;
};




class AccessNode {

private:
  Choices::Choice _type;


  union {
    class MultipleTypeConstraints *u_MultipleTypeConstraints;
    class TS_ConstRefList *u_TS_ConstRefList;
    class InvalidFieldEncodingDefs *u_InvalidFieldEncodingDefs;
    class AEXPLICIT *u_AEXPLICIT;
    class AnyDefinedBy *u_AnyDefinedBy;
    class ValueBound *u_ValueBound;
    class Pass *u_Pass;
    class CM_Id *u_CM_Id;
    class PCO_List *u_PCO_List;
    class TC_VarDcl *u_TC_VarDcl;
    class RecordRef *u_RecordRef;
    class TTCN_Type *u_TTCN_Type;
    class SO_StructureAndObjectives *u_SO_StructureAndObjectives;
    class R_TYPE *u_R_TYPE;
    class ParentSubType *u_ParentSubType;
    class VariationRef *u_VariationRef;
    class TS_ProcId *u_TS_ProcId;
    class Configuration *u_Configuration;
    class SO_StepIndex *u_SO_StepIndex;
    class Mult *u_Mult;
    class BuiltinType *u_BuiltinType;
    class CM_ParValues *u_CM_ParValues;
    class ExpandedId *u_ExpandedId;
    class ASN1_TypeDefs *u_ASN1_TypeDefs;
    class ArrayRef *u_ArrayRef;
    class TestGroup *u_TestGroup;
    class TS_VarId *u_TS_VarId;
    class TS_ProcDefs *u_TS_ProcDefs;
    class ASN1_ValueList *u_ASN1_ValueList;
    class ASN1_PDU_TypeDefByRefList *u_ASN1_PDU_TypeDefByRefList;
    class PCO_Dcls *u_PCO_Dcls;
    class ASP_ParValues *u_ASP_ParValues;
    class EncodingVariations *u_EncodingVariations;
    class SpecialRealValue *u_SpecialRealValue;
    class ReadTimer *u_ReadTimer;
    class ObjectName *u_ObjectName;
    class PartialSpecification *u_PartialSpecification;
    class TCompIdList *u_TCompIdList;
    class Event *u_Event;
    class PDU_FieldValues *u_PDU_FieldValues;
    class TTCN_ASP_TypeDef *u_TTCN_ASP_TypeDef;
    class InvalidFieldEncodingId *u_InvalidFieldEncodingId;
    class Max *u_Max;
    class Inconclusive *u_Inconclusive;
    class PICS_PIXITref *u_PICS_PIXITref;
    class ObjIdComponentList *u_ObjIdComponentList;
    class DefaultGroupOrDefault *u_DefaultGroupOrDefault;
    class Result *u_Result;
    class ASP_ParIdOrMacro *u_ASP_ParIdOrMacro;
    class PCO_DclList *u_PCO_DclList;
    class TC_Role *u_TC_Role;
    class StructId *u_StructId;
    class MinusINFINITY *u_MinusINFINITY;
    class NullValue *u_NullValue;
    class TestStepLibrary *u_TestStepLibrary;
    class NumberForm *u_NumberForm;
    class ClassType *u_ClassType;
    class Label *u_Label;
    class Replacement *u_Replacement;
    class TTCN_ASP_Constraints *u_TTCN_ASP_Constraints;
    class SimpleValueList *u_SimpleValueList;
    class Comment *u_Comment;
    class UpperValueBound *u_UpperValueBound;
    class Assignment *u_Assignment;
    class TestCases *u_TestCases;
    class ImportedObject *u_ImportedObject;
    class SO_Description *u_SO_Description;
    class SingleValue *u_SingleValue;
    class DefaultExpression *u_DefaultExpression;
    class ASN1_ConsValue *u_ASN1_ConsValue;
    class TS_TypeConstraints *u_TS_TypeConstraints;
    class And *u_And;
    class NamedValue *u_NamedValue;
    class LocalTreeList *u_LocalTreeList;
    class EncodingVariationId *u_EncodingVariationId;
    class Expression *u_Expression;
    class TTCN_CM_TypeDefs *u_TTCN_CM_TypeDefs;
    class SignedNumber *u_SignedNumber;
    class Header *u_Header;
    class CreateAttach *u_CreateAttach;
    class TestPurpose *u_TestPurpose;
    class RangeTypeLength *u_RangeTypeLength;
    class TS_ProcDef *u_TS_ProcDef;
    class TypeAndAttributes *u_TypeAndAttributes;
    class Two *u_Two;
    class SetOfValue *u_SetOfValue;
    class DefaultIndex *u_DefaultIndex;
    class UpperBound *u_UpperBound;
    class PDU *u_PDU;
    class ANY *u_ANY;
    class DefaultGroupReference *u_DefaultGroupReference;
    class Enumeration *u_Enumeration;
    class SelectionType *u_SelectionType;
    class AssignmentList *u_AssignmentList;
    class BehaviourLineList *u_BehaviourLineList;
    class PDU_FieldIdAndFullId *u_PDU_FieldIdAndFullId;
    class PDU_EncodingId *u_PDU_EncodingId;
    class SetSubType *u_SetSubType;
    class ElementType *u_ElementType;
    class Timeout *u_Timeout;
    class ASN1_ASP_TypeDefs *u_ASN1_ASP_TypeDefs;
    class SelectExpr *u_SelectExpr;
    class SO_DefaultId *u_SO_DefaultId;
    class StructTypeDefs *u_StructTypeDefs;
    class ComponentsOf *u_ComponentsOf;
    class BitNumber *u_BitNumber;
    class AddOp *u_AddOp;
    class ValRange *u_ValRange;
    class ASN1_TypeId *u_ASN1_TypeId;
    class ElemId *u_ElemId;
    class SO_TestMethods *u_SO_TestMethods;
    class Equal *u_Equal;
    class WithComponent *u_WithComponent;
    class ClassNumber *u_ClassNumber;
    class NamedBitList *u_NamedBitList;
    class Repeat *u_Repeat;
    class SuiteId *u_SuiteId;
    class GreaterOrEqual *u_GreaterOrEqual;
    class OPTIONAL *u_OPTIONAL;
    class PDU_FieldType *u_PDU_FieldType;
    class PCOs_Used *u_PCOs_Used;
    class SO_DefaultRef *u_SO_DefaultRef;
    class ObjectType *u_ObjectType;
    class DefaultIdAndParList *u_DefaultIdAndParList;
    class CM_ParType *u_CM_ParType;
    class ChoiceValue *u_ChoiceValue;
    class ElemValues *u_ElemValues;
    class ConsId *u_ConsId;
    class ASN1_TypeRefs *u_ASN1_TypeRefs;
    class SuiteStructure *u_SuiteStructure;
    class VariationReference *u_VariationReference;
    class TS_ParId *u_TS_ParId;
    class NullType *u_NullType;
    class Min *u_Min;
    class NamedTypeOrSelection *u_NamedTypeOrSelection;
    class CM_ParId *u_CM_ParId;
    class Mantissa *u_Mantissa;
    class R_Value *u_R_Value;
    class CM_Constraints *u_CM_Constraints;
    class AliasDefs *u_AliasDefs;
    class PCO_TypeDcls *u_PCO_TypeDcls;
    class SimpleTypeId *u_SimpleTypeId;
    class EncVariationId *u_EncVariationId;
    class SO_TestCaseId *u_SO_TestCaseId;
    class VideotexString *u_VideotexString;
    class SubType *u_SubType;
    class Primary *u_Primary;
    class DefaultGroup *u_DefaultGroup;
    class ASP_ParId *u_ASP_ParId;
    class TC_VarDclList *u_TC_VarDclList;
    class ATrue *u_ATrue;
    class VisibleString *u_VisibleString;
    class ContainedSubType *u_ContainedSubType;
    class BooleanValue *u_BooleanValue;
    class TS_VarDcl *u_TS_VarDcl;
    class ASN1_ValueReference *u_ASN1_ValueReference;
    class UsefulType *u_UsefulType;
    class AliasId *u_AliasId;
    class ASP_TypeDefs *u_ASP_TypeDefs;
    class BITSTRING *u_BITSTRING;
    class ChoiceType *u_ChoiceType;
    class Encoding_TypeList *u_Encoding_TypeList;
    class DefaultReference *u_DefaultReference;
    class TS_VarType *u_TS_VarType;
    class TypeOrPDU *u_TypeOrPDU;
    class GeneralString *u_GeneralString;
    class Cstring *u_Cstring;
    class ParentType *u_ParentType;
    class ComponentPosition *u_ComponentPosition;
    class EventStatement *u_EventStatement;
    class TCompUsed *u_TCompUsed;
    class LessOrEqual *u_LessOrEqual;
    class Less *u_Less;
    class OMIT *u_OMIT;
    class TestStepIdAndParList *u_TestStepIdAndParList;
    class Activate *u_Activate;
    class ASN1_TypeDef *u_ASN1_TypeDef;
    class RealType *u_RealType;
    class NamedConstraintList *u_NamedConstraintList;
    class SingleTypeConstraint *u_SingleTypeConstraint;
    class ASN1_CM_Constraint *u_ASN1_CM_Constraint;
    class TS_OpDefs *u_TS_OpDefs;
    class Div *u_Div;
    class TTCN_PDU_TypeDef *u_TTCN_PDU_TypeDef;
    class SO_TestStepId *u_SO_TestStepId;
    class Mod *u_Mod;
    class ValueAttributes *u_ValueAttributes;
    class LowerBound *u_LowerBound;
    class PicoSeconds *u_PicoSeconds;
    class FormalParType *u_FormalParType;
    class ASN1_ASP_TypeDef *u_ASN1_ASP_TypeDef;
    class TimerDcls *u_TimerDcls;
    class SelectExprId *u_SelectExprId;
    class SO_SuiteId *u_SO_SuiteId;
    class SequenceSubType *u_SequenceSubType;
    class Attach *u_Attach;
    class TCompConfigDcls *u_TCompConfigDcls;
    class SO_TestGroupRef *u_SO_TestGroupRef;
    class Minus *u_Minus;
    class Num_CPs *u_Num_CPs;
    class SimpleTypeDef *u_SimpleTypeDef;
    class ImportedObjectList *u_ImportedObjectList;
    class PrintableString *u_PrintableString;
    class TaggedType *u_TaggedType;
    class TestStepAttachment *u_TestStepAttachment;
    class NONE *u_NONE;
    class OCTETSTRING *u_OCTETSTRING;
    class ObjIdComponent *u_ObjIdComponent;
    class AnyType *u_AnyType;
    class InvalidFieldEncodingDefinition *u_InvalidFieldEncodingDefinition;
    class AnyOrOmit *u_AnyOrOmit;
    class TIMER *u_TIMER;
    class NamedType *u_NamedType;
    class ComponentIdentifier *u_ComponentIdentifier;
    class TS_ConstValue *u_TS_ConstValue;
    class TS_OpDescription *u_TS_OpDescription;
    class TS_TypeDefs *u_TS_TypeDefs;
    class ObjectIdentifierType *u_ObjectIdentifierType;
    class AlternativeTypeList *u_AlternativeTypeList;
    class UnaryExpression *u_UnaryExpression;
    class TestStepRef *u_TestStepRef;
    class StartTimer *u_StartTimer;
    class ImplicitSend *u_ImplicitSend;
    class PDU_FieldDcls *u_PDU_FieldDcls;
    class StructIdAndFullId *u_StructIdAndFullId;
    class EncodingVariation *u_EncodingVariation;
    class INFINITY *u_INFINITY;
    class DefinedValue *u_DefinedValue;
    class CM_ParDcls *u_CM_ParDcls;
    class SourceName *u_SourceName;
    class ASN1_TypeRef *u_ASN1_TypeRef;
    class ASN1_TypeAndLocalTypes *u_ASN1_TypeAndLocalTypes;
    class TestGroupOrTestCaseList *u_TestGroupOrTestCaseList;
    class MacroSymbol *u_MacroSymbol;
    class ASN1_LocalTypes *u_ASN1_LocalTypes;
    class ASN1_CM_TypeDefs *u_ASN1_CM_TypeDefs;
    class ASP_IdAndFullId *u_ASP_IdAndFullId;
    class NumOf_PCOs *u_NumOf_PCOs;
    class SO_PICSRef *u_SO_PICSRef;
    class DetailedComment *u_DetailedComment;
    class Greater *u_Greater;
    class UTCTime *u_UTCTime;
    class TCompConfigId *u_TCompConfigId;
    class SO_PIXITRef *u_SO_PIXITRef;
    class SimpleValue *u_SimpleValue;
    class SelectExprDefs *u_SelectExprDefs;
    class EncodingDefs *u_EncodingDefs;
    class TS_ProcResult *u_TS_ProcResult;
    class TreeHeader *u_TreeHeader;
    class TestGroupOrTestCase *u_TestGroupOrTestCase;
    class PCO_Id *u_PCO_Id;
    class TS_ConstId *u_TS_ConstId;
    class IntegerRange *u_IntegerRange;
    class CompactTestCaseList *u_CompactTestCaseList;
    class ASN1_ModuleId *u_ASN1_ModuleId;
    class ElemIdAndFullId *u_ElemIdAndFullId;
    class INTEGER *u_INTEGER;
    class Line *u_Line;
    class TTCN_PDU_Constraints *u_TTCN_PDU_Constraints;
    class PCO_TypeDcl *u_PCO_TypeDcl;
    class TS_ConstRefs *u_TS_ConstRefs;
    class SingleLength *u_SingleLength;
    class UpperTypeBound *u_UpperTypeBound;
    class LowerTypeBound *u_LowerTypeBound;
    class ComponentNumber *u_ComponentNumber;
    class DefaultRef *u_DefaultRef;
    class ASN1_PDU_Constraint *u_ASN1_PDU_Constraint;
    class TTCN_ASP_TypeDefs *u_TTCN_ASP_TypeDefs;
    class PCO_Dcl *u_PCO_Dcl;
    class APPLICATION *u_APPLICATION;
    class FormalParList *u_FormalParList;
    class SelectionValue *u_SelectionValue;
    class SequenceOfValue *u_SequenceOfValue;
    class CreateTComp *u_CreateTComp;
    class ASP_ParDcl *u_ASP_ParDcl;
    class Duration *u_Duration;
    class TCompConfigDcl *u_TCompConfigDcl;
    class TS_VarDcls *u_TS_VarDcls;
    class OctetStringType *u_OctetStringType;
    class ASN1_PDU_TypeDefByRef *u_ASN1_PDU_TypeDefByRef;
    class TS_OpResult *u_TS_OpResult;
    class InvalidFieldEncodingCall *u_InvalidFieldEncodingCall;
    class ASP_Constraints *u_ASP_Constraints;
    class EncRuleId *u_EncRuleId;
    class InvalidFieldEncodingDef *u_InvalidFieldEncodingDef;
    class Imports *u_Imports;
    class TeletexString *u_TeletexString;
    class Create *u_Create;
    class TestCaseId *u_TestCaseId;
    class ASN1_ASP_TypeDefByRefList *u_ASN1_ASP_TypeDefByRefList;
    class TCompId *u_TCompId;
    class PTC *u_PTC;
    class PRESENT *u_PRESENT;
    class DefaultValue *u_DefaultValue;
    class Exponent *u_Exponent;
    class ValueRange *u_ValueRange;
    class IdOrNum *u_IdOrNum;
    class DeclarationsPart *u_DeclarationsPart;
    class ReferenceType *u_ReferenceType;
    class EncodingVariationSet *u_EncodingVariationSet;
    class Plus *u_Plus;
    class TestStepGroupReference *u_TestStepGroupReference;
    class InnerTypeConstraints *u_InnerTypeConstraints;
    class Omit *u_Omit;
    class ConstraintExpression *u_ConstraintExpression;
    class ConsRef *u_ConsRef;
    class CompactTestGroup *u_CompactTestGroup;
    class EncodingDefList *u_EncodingDefList;
    class TS_ParDcl *u_TS_ParDcl;
    class AnyValue *u_AnyValue;
    class DefinedType *u_DefinedType;
    class TTCN_PDU_Constraint *u_TTCN_PDU_Constraint;
    class TCompConfigInfoList *u_TCompConfigInfoList;
    class UT *u_UT;
    class PRIVATE_ *u_PRIVATE_;
    class Tag *u_Tag;
    class MultExpression *u_MultExpression;
    class UpperRangeBound *u_UpperRangeBound;
    class SO_DefIndexList *u_SO_DefIndexList;
    class EncodingReference *u_EncodingReference;
    class BitRef *u_BitRef;
    class UnaryOp *u_UnaryOp;
    class ASP_ParIdAndFullId *u_ASP_ParIdAndFullId;
    class TimerId *u_TimerId;
    class TimerDcl *u_TimerDcl;
    class P_Role *u_P_Role;
    class TS_ParType *u_TS_ParType;
    class FullIdentifier *u_FullIdentifier;
    class EncVariationIdAndParList *u_EncVariationIdAndParList;
    class ObjectDescriptor *u_ObjectDescriptor;
    class T61String *u_T61String;
    class ObjectIdentifierValue *u_ObjectIdentifierValue;
    class LowerValueBound *u_LowerValueBound;
    class PCO_TypeId *u_PCO_TypeId;
    class TestCaseIndex *u_TestCaseIndex;
    class Constraint *u_Constraint;
    class SizeConstraint *u_SizeConstraint;
    class ASN1_ASP_Constraint *u_ASN1_ASP_Constraint;
    class ASP_Id *u_ASP_Id;
    class SimpleTypeDefinition *u_SimpleTypeDefinition;
    class IntegerType *u_IntegerType;
    class ArrayRefOrComp *u_ArrayRefOrComp;
    class CM_TypeDefs *u_CM_TypeDefs;
    class NameAndNumberForm *u_NameAndNumberForm;
    class SetOfType *u_SetOfType;
    class Factor *u_Factor;
    class TestStepId *u_TestStepId;
    class BehaviourLine *u_BehaviourLine;
    class Children *u_Children;
    class Objective *u_Objective;
    class ValueList *u_ValueList;
    class CP_DclList *u_CP_DclList;
    class SuiteOverviewPart *u_SuiteOverviewPart;
    class ANYValue *u_ANYValue;
    class MultOp *u_MultOp;
    class ASN1_PDU_TypeDef *u_ASN1_PDU_TypeDef;
    class VariationDefault *u_VariationDefault;
    class IF_PRESENT *u_IF_PRESENT;
    class ASN1_ASP_Constraints *u_ASN1_ASP_Constraints;
    class CM_ParIdOrMacro *u_CM_ParIdOrMacro;
    class Or *u_Or;
    class DefaultCase *u_DefaultCase;
    class TestStepGroup *u_TestStepGroup;
    class StructTypeConstraints *u_StructTypeConstraints;
    class CP_Id *u_CP_Id;
    class ASN1_TypeRefList *u_ASN1_TypeRefList;
    class StructTypeDef *u_StructTypeDef;
    class TestGroupReference *u_TestGroupReference;
    class Base *u_Base;
    class NameForm *u_NameForm;
    class TTCN_ASP_Constraint *u_TTCN_ASP_Constraint;
    class FormalParIdList *u_FormalParIdList;
    class NamedNumberList *u_NamedNumberList;
    class PDU_FieldDcl *u_PDU_FieldDcl;
    class EncodingRuleId *u_EncodingRuleId;
    class ElemDcl *u_ElemDcl;
    class LocalTree *u_LocalTree;
    class ReferenceList *u_ReferenceList;
    class TimeUnit *u_TimeUnit;
    class NotEqual *u_NotEqual;
    class NamedConstraint *u_NamedConstraint;
    class NamedNumber *u_NamedNumber;
    class PDU_FieldIdOrMacro *u_PDU_FieldIdOrMacro;
    class SimpleTypeDefs *u_SimpleTypeDefs;
    class SetValue *u_SetValue;
    class CM_ParIdAndFullId *u_CM_ParIdAndFullId;
    class PDU_FieldId *u_PDU_FieldId;
    class TC_VarId *u_TC_VarId;
    class Hstring *u_Hstring;
    class LowerEndValue *u_LowerEndValue;
    class Declarations *u_Declarations;
    class TestStepIndex *u_TestStepIndex;
    class TypeAndLengthAttribute *u_TypeAndLengthAttribute;
    class NanoSeconds *u_NanoSeconds;
    class NamedTypeAttribute *u_NamedTypeAttribute;
    class Expansion *u_Expansion;
    class ComponentReferenceList *u_ComponentReferenceList;
    class RootTree *u_RootTree;
    class Description *u_Description;
    class NumOf_CPs *u_NumOf_CPs;
    class SO_StepIndexList *u_SO_StepIndexList;
    class ElemType *u_ElemType;
    class R *u_R;
    class Minutes *u_Minutes;
    class IdentifierList *u_IdentifierList;
    class TypeReference *u_TypeReference;
    class ActualCrefParList *u_ActualCrefParList;
    class SelExprId *u_SelExprId;
    class ASN1_TypeConstraint *u_ASN1_TypeConstraint;
    class DerivationPath *u_DerivationPath;
    class TCompDclList *u_TCompDclList;
    class TS_ProcIdAndParList *u_TS_ProcIdAndParList;
    class SequenceType *u_SequenceType;
    class ASP_ParType *u_ASP_ParType;
    class PDU_FieldEncoding *u_PDU_FieldEncoding;
    class INCONC *u_INCONC;
    class UNIVERSAL *u_UNIVERSAL;
    class DefaultRefList *u_DefaultRefList;
    class ASP_ParValue *u_ASP_ParValue;
    class TC_VarValue *u_TC_VarValue;
    class TC_VarType *u_TC_VarType;
    class EncodingDefinition *u_EncodingDefinition;
    class ASN1_TypeReference *u_ASN1_TypeReference;
    class Not *u_Not;
    class Ten *u_Ten;
    class NumericRealValue *u_NumericRealValue;
    class TypeAssignmentList *u_TypeAssignmentList;
    class DynamicPart *u_DynamicPart;
    class AliasDefList *u_AliasDefList;
    class CP_List *u_CP_List;
    class CPs_Used *u_CPs_Used;
    class OmitReference *u_OmitReference;
    class TTCN_CM_TypeDef *u_TTCN_CM_TypeDef;
    class TS_ConstDclList *u_TS_ConstDclList;
    class LengthRestriction *u_LengthRestriction;
    class TS_ParDcls *u_TS_ParDcls;
    class TestStepGroupId *u_TestStepGroupId;
    class CP_Dcl *u_CP_Dcl;
    class TS_VarDclList *u_TS_VarDclList;
    class RealValue *u_RealValue;
    class TCompDcls *u_TCompDcls;
    class DeclarationValue *u_DeclarationValue;
    class SelectionExpression *u_SelectionExpression;
    class PredefinedType *u_PredefinedType;
    class BooleanType *u_BooleanType;
    class Send *u_Send;
    class ASN1_CM_TypeDef *u_ASN1_CM_TypeDef;
    class ConstraintValueAndAttributesOrReplace *u_ConstraintValueAndAttributesOrReplace;
    class InvalidFieldEncodingIdAndParList *u_InvalidFieldEncodingIdAndParList;
    class ConstraintValueAndAttributes *u_ConstraintValueAndAttributes;
    class Qualifier *u_Qualifier;
    class PDU_IdAndFullId *u_PDU_IdAndFullId;
    class CP_Dcls *u_CP_Dcls;
    class SelectExprDef *u_SelectExprDef;
    class CharacterString *u_CharacterString;
    class ISO646String *u_ISO646String;
    class TypeAssignment *u_TypeAssignment;
    class ParenExpression *u_ParenExpression;
    class DefaultId *u_DefaultId;
    class TestStep *u_TestStep;
    class CreateList *u_CreateList;
    class ConstraintsPart *u_ConstraintsPart;
    class ASN1_PDU_TypeDefs *u_ASN1_PDU_TypeDefs;
    class NumericString *u_NumericString;
    class BitIdentifier *u_BitIdentifier;
    class MatchingSymbol *u_MatchingSymbol;
    class TestGroupRef *u_TestGroupRef;
    class TimerDclList *u_TimerDclList;
    class TS_ParDclList *u_TS_ParDclList;
    class FormalParAndType *u_FormalParAndType;
    class ReplacementList *u_ReplacementList;
    class Minus_INFINITY *u_Minus_INFINITY;
    class GraphicString *u_GraphicString;
    class ElementTypeList *u_ElementTypeList;
    class AddExpression *u_AddExpression;
    class RETURN_ *u_RETURN_;
    class LT *u_LT;
    class Identifier *u_Identifier;
    class PresenceConstraint *u_PresenceConstraint;
    class ComponentReference *u_ComponentReference;
    class SingleValueLength *u_SingleValueLength;
    class TestGroupId *u_TestGroupId;
    class GoTo *u_GoTo;
    class TS_OpId *u_TS_OpId;
    class ASuite *u_ASuite;
    class FAIL *u_FAIL;
    class Plus_INFINITY *u_Plus_INFINITY;
    class SimpleExpression *u_SimpleExpression;
    class ConsValue *u_ConsValue;
    class TS_ConstDcl *u_TS_ConstDcl;
    class SO_StandardsRef *u_SO_StandardsRef;
    class EncVariationCall *u_EncVariationCall;
    class AFalse *u_AFalse;
    class PreliminaryFAIL *u_PreliminaryFAIL;
    class OpCall *u_OpCall;
    class SuperSet *u_SuperSet;
    class LowerRangeBound *u_LowerRangeBound;
    class TimerOp *u_TimerOp;
    class ElemValue *u_ElemValue;
    class SourceRef *u_SourceRef;
    class UpperEndValue *u_UpperEndValue;
    class SubTypeSpec *u_SubTypeSpec;
    class Term *u_Term;
    class PDU_Constraints *u_PDU_Constraints;
    class PCO_Role *u_PCO_Role;
    class ElementValueList *u_ElementValueList;
    class SequenceValue *u_SequenceValue;
    class SequenceOfType *u_SequenceOfType;
    class EncodingDefault *u_EncodingDefault;
    class TestStepGroupOrTestStep *u_TestStepGroupOrTestStep;
    class WithComponents *u_WithComponents;
    class BehaviourDescription *u_BehaviourDescription;
    class CompactTestCase *u_CompactTestCase;
    class CM_ParValue *u_CM_ParValue;
    class TTCN_CM_Constraint *u_TTCN_CM_Constraint;
    class PDU_TypeDefs *u_PDU_TypeDefs;
    class TCompDcl *u_TCompDcl;
    class TS_ConstType *u_TS_ConstType;
    class ElemDcls *u_ElemDcls;
    class LengthAttribute *u_LengthAttribute;
    class Permutation *u_Permutation;
    class DefaultsLibrary *u_DefaultsLibrary;
    class DerivPath *u_DerivPath;
    class ImportPart *u_ImportPart;
    class PASS *u_PASS;
    class MTC *u_MTC;
    class SubtypeValueSet *u_SubtypeValueSet;
    class EnumeratedType *u_EnumeratedType;
    class DefaultGroupOrDefaultList *u_DefaultGroupOrDefaultList;
    class Otherwise *u_Otherwise;
    class LabelId *u_LabelId;
    class TTCN_CM_Constraints *u_TTCN_CM_Constraints;
    class ASN1_ASP_TypeDefsByRef *u_ASN1_ASP_TypeDefsByRef;
    class ASP_ParDcls *u_ASP_ParDcls;
    class Num_PCOs *u_Num_PCOs;
    class PreliminaryINCONC *u_PreliminaryINCONC;
    class PreliminaryPASS *u_PreliminaryPASS;
    class ABSENT *u_ABSENT;
    class Done *u_Done;
    class TC_VarDcls *u_TC_VarDcls;
    class TS_VarValue *u_TS_VarValue;
    class TS_ProcDescription *u_TS_ProcDescription;
    class EncodingDefinitions *u_EncodingDefinitions;
    class SingleTypeLength *u_SingleTypeLength;
    class IA5String *u_IA5String;
    class Ostring *u_Ostring;
    class RangeValueLength *u_RangeValueLength;
    class Verdict *u_Verdict;
    class ASN1_PDU_TypeDefsByRef *u_ASN1_PDU_TypeDefsByRef;
    class PDU_Id *u_PDU_Id;
    class ComplexDefinitions *u_ComplexDefinitions;
    class SelectExprDefList *u_SelectExprDefList;
    class ASN1_TypeDefinition *u_ASN1_TypeDefinition;
    class SubSet *u_SubSet;
    class Complement *u_Complement;
    class VerdictId *u_VerdictId;
    class DefaultsRef *u_DefaultsRef;
    class Bstring *u_Bstring;
    class TagAttributes *u_TagAttributes;
    class ActualParList *u_ActualParList;
    class ValueLength *u_ValueLength;
    class TestStepGroupOrTestStepList *u_TestStepGroupOrTestStepList;
    class Cref *u_Cref;
    class TimerOps *u_TimerOps;
    class TestCase *u_TestCase;
    class ASN1_TypeConstraints *u_ASN1_TypeConstraints;
    class CM_ParDcl *u_CM_ParDcl;
    class ASN1_Type *u_ASN1_Type;
    class TimerValue *u_TimerValue;
    class PDU_FieldValue *u_PDU_FieldValue;
    class TS_ConstRef *u_TS_ConstRef;
    class EXTERNAL *u_EXTERNAL;
    class Indentation *u_Indentation;
    class TypeConstraints *u_TypeConstraints;
    class LiteralValue *u_LiteralValue;
    class StatementLine *u_StatementLine;
    class SO_TestStepRef *u_SO_TestStepRef;
    class HEXSTRING *u_HEXSTRING;
    class NamedTypeAndAttributes *u_NamedTypeAndAttributes;
    class ConstraintReference *u_ConstraintReference;
    class ASN1_PDU_Constraints *u_ASN1_PDU_Constraints;
    class ConsIdAndParList *u_ConsIdAndParList;
    class SO_Objective *u_SO_Objective;
    class ParamAndSelection *u_ParamAndSelection;
    class Receive *u_Receive;
    class ASN1_CM_Constraints *u_ASN1_CM_Constraints;
    class PCO_Type *u_PCO_Type;
    class TComp_Role *u_TComp_Role;
    class Definitions *u_Definitions;
    class Seconds *u_Seconds;
    class ValueConstraint *u_ValueConstraint;
    class DataObjectReference *u_DataObjectReference;
    class AliasDef *u_AliasDef;
    class AIMPLICIT *u_AIMPLICIT;
    class BitStringValue *u_BitStringValue;
    class Value *u_Value;
    class RelOp *u_RelOp;
    class RelExpression *u_RelExpression;
    class LineNumber *u_LineNumber;
    class Number *u_Number;
    class TypeAndRestriction *u_TypeAndRestriction;
    class TS_OpIdAndParList *u_TS_OpIdAndParList;
    class LowerEndpoint *u_LowerEndpoint;
    class ASN1_Value *u_ASN1_Value;
    class CancelTimer *u_CancelTimer;
    class ImportDeclarations *u_ImportDeclarations;
    class BOOLEAN *u_BOOLEAN;
    class Replace *u_Replace;
    class TCompConfigInfo *u_TCompConfigInfo;
    class SO_CaseIndex *u_SO_CaseIndex;
    class TS_OpDef *u_TS_OpDef;
    class ConstraintValue *u_ConstraintValue;
    class SO_StructureAndObjective *u_SO_StructureAndObjective;
    class PDU_FieldEncodingCall *u_PDU_FieldEncodingCall;
    class FullSpecification *u_FullSpecification;
    class UpperEndpoint *u_UpperEndpoint;
    class PermittedAlphabet *u_PermittedAlphabet;
    class BitStringType *u_BitStringType;
    class TreeReference *u_TreeReference;
    class MicroSeconds *u_MicroSeconds;
    class Fail *u_Fail;
    class StructTypeConstraint *u_StructTypeConstraint;
    class ASN1_ASP_TypeDefByRef *u_ASN1_ASP_TypeDefByRef;
    class Restriction *u_Restriction;
    class EncodingRef *u_EncodingRef;
    class SO_DefIndex *u_SO_DefIndex;
    class Construct *u_Construct;
    class Unit *u_Unit;
    class TS_ConstDcls *u_TS_ConstDcls;
    class MilliSeconds *u_MilliSeconds;
    class CP *u_CP;
    class TTCN_PDU_TypeDefs *u_TTCN_PDU_TypeDefs;
    class PCO_TypeDclList *u_PCO_TypeDclList;
    class EncodingVariationList *u_EncodingVariationList;
    class INCLUSIVE *u_INCLUSIVE;
    class SetType *u_SetType;
    class SO_SelExprId *u_SO_SelExprId;
    class Bound *u_Bound;
    class GeneralizedTime *u_GeneralizedTime;
    class DefaultGroupId *u_DefaultGroupId;
    class RangeLength *u_RangeLength;
    class SimpleTypeDefList *u_SimpleTypeDefList;
    class SO_CaseIndexList *u_SO_CaseIndexList;
  };



public:
  AccessNode();
  AccessNode(NodeInfo nodeinfo);
  ~AccessNode();
  AccessNode(const AccessNode& Me);
  int operator==(const AccessNode& o) const;
  Boolean is_equal(const AccessNode& o) const;
  void operator=(const AccessNode& orig);
friend FILE& operator<<(FILE& f,const AccessNode& o);
  Choices::Choice choice() const;
  Boolean ok() const;
  ITEXACCESS_DEREF(AccessNode)


  AccessNode(const class MultipleTypeConstraints& Me);
  AccessNode(const class TS_ConstRefList& Me);
  AccessNode(const class InvalidFieldEncodingDefs& Me);
  AccessNode(const class AEXPLICIT& Me);
  AccessNode(const class AnyDefinedBy& Me);
  AccessNode(const class ValueBound& Me);
  AccessNode(const class Pass& Me);
  AccessNode(const class CM_Id& Me);
  AccessNode(const class PCO_List& Me);
  AccessNode(const class TC_VarDcl& Me);
  AccessNode(const class RecordRef& Me);
  AccessNode(const class TTCN_Type& Me);
  AccessNode(const class SO_StructureAndObjectives& Me);
  AccessNode(const class R_TYPE& Me);
  AccessNode(const class ParentSubType& Me);
  AccessNode(const class VariationRef& Me);
  AccessNode(const class TS_ProcId& Me);
  AccessNode(const class Configuration& Me);
  AccessNode(const class SO_StepIndex& Me);
  AccessNode(const class Mult& Me);
  AccessNode(const class BuiltinType& Me);
  AccessNode(const class CM_ParValues& Me);
  AccessNode(const class ExpandedId& Me);
  AccessNode(const class ASN1_TypeDefs& Me);
  AccessNode(const class ArrayRef& Me);
  AccessNode(const class TestGroup& Me);
  AccessNode(const class TS_VarId& Me);
  AccessNode(const class TS_ProcDefs& Me);
  AccessNode(const class ASN1_ValueList& Me);
  AccessNode(const class ASN1_PDU_TypeDefByRefList& Me);
  AccessNode(const class PCO_Dcls& Me);
  AccessNode(const class ASP_ParValues& Me);
  AccessNode(const class EncodingVariations& Me);
  AccessNode(const class SpecialRealValue& Me);
  AccessNode(const class ReadTimer& Me);
  AccessNode(const class ObjectName& Me);
  AccessNode(const class PartialSpecification& Me);
  AccessNode(const class TCompIdList& Me);
  AccessNode(const class Event& Me);
  AccessNode(const class PDU_FieldValues& Me);
  AccessNode(const class TTCN_ASP_TypeDef& Me);
  AccessNode(const class InvalidFieldEncodingId& Me);
  AccessNode(const class Max& Me);
  AccessNode(const class Inconclusive& Me);
  AccessNode(const class PICS_PIXITref& Me);
  AccessNode(const class ObjIdComponentList& Me);
  AccessNode(const class DefaultGroupOrDefault& Me);
  AccessNode(const class Result& Me);
  AccessNode(const class ASP_ParIdOrMacro& Me);
  AccessNode(const class PCO_DclList& Me);
  AccessNode(const class TC_Role& Me);
  AccessNode(const class StructId& Me);
  AccessNode(const class MinusINFINITY& Me);
  AccessNode(const class NullValue& Me);
  AccessNode(const class TestStepLibrary& Me);
  AccessNode(const class NumberForm& Me);
  AccessNode(const class ClassType& Me);
  AccessNode(const class Label& Me);
  AccessNode(const class Replacement& Me);
  AccessNode(const class TTCN_ASP_Constraints& Me);
  AccessNode(const class SimpleValueList& Me);
  AccessNode(const class Comment& Me);
  AccessNode(const class UpperValueBound& Me);
  AccessNode(const class Assignment& Me);
  AccessNode(const class TestCases& Me);
  AccessNode(const class ImportedObject& Me);
  AccessNode(const class SO_Description& Me);
  AccessNode(const class SingleValue& Me);
  AccessNode(const class DefaultExpression& Me);
  AccessNode(const class ASN1_ConsValue& Me);
  AccessNode(const class TS_TypeConstraints& Me);
  AccessNode(const class And& Me);
  AccessNode(const class NamedValue& Me);
  AccessNode(const class LocalTreeList& Me);
  AccessNode(const class EncodingVariationId& Me);
  AccessNode(const class Expression& Me);
  AccessNode(const class TTCN_CM_TypeDefs& Me);
  AccessNode(const class SignedNumber& Me);
  AccessNode(const class Header& Me);
  AccessNode(const class CreateAttach& Me);
  AccessNode(const class TestPurpose& Me);
  AccessNode(const class RangeTypeLength& Me);
  AccessNode(const class TS_ProcDef& Me);
  AccessNode(const class TypeAndAttributes& Me);
  AccessNode(const class Two& Me);
  AccessNode(const class SetOfValue& Me);
  AccessNode(const class DefaultIndex& Me);
  AccessNode(const class UpperBound& Me);
  AccessNode(const class PDU& Me);
  AccessNode(const class ANY& Me);
  AccessNode(const class DefaultGroupReference& Me);
  AccessNode(const class Enumeration& Me);
  AccessNode(const class SelectionType& Me);
  AccessNode(const class AssignmentList& Me);
  AccessNode(const class BehaviourLineList& Me);
  AccessNode(const class PDU_FieldIdAndFullId& Me);
  AccessNode(const class PDU_EncodingId& Me);
  AccessNode(const class SetSubType& Me);
  AccessNode(const class ElementType& Me);
  AccessNode(const class Timeout& Me);
  AccessNode(const class ASN1_ASP_TypeDefs& Me);
  AccessNode(const class SelectExpr& Me);
  AccessNode(const class SO_DefaultId& Me);
  AccessNode(const class StructTypeDefs& Me);
  AccessNode(const class ComponentsOf& Me);
  AccessNode(const class BitNumber& Me);
  AccessNode(const class AddOp& Me);
  AccessNode(const class ValRange& Me);
  AccessNode(const class ASN1_TypeId& Me);
  AccessNode(const class ElemId& Me);
  AccessNode(const class SO_TestMethods& Me);
  AccessNode(const class Equal& Me);
  AccessNode(const class WithComponent& Me);
  AccessNode(const class ClassNumber& Me);
  AccessNode(const class NamedBitList& Me);
  AccessNode(const class Repeat& Me);
  AccessNode(const class SuiteId& Me);
  AccessNode(const class GreaterOrEqual& Me);
  AccessNode(const class OPTIONAL& Me);
  AccessNode(const class PDU_FieldType& Me);
  AccessNode(const class PCOs_Used& Me);
  AccessNode(const class SO_DefaultRef& Me);
  AccessNode(const class ObjectType& Me);
  AccessNode(const class DefaultIdAndParList& Me);
  AccessNode(const class CM_ParType& Me);
  AccessNode(const class ChoiceValue& Me);
  AccessNode(const class ElemValues& Me);
  AccessNode(const class ConsId& Me);
  AccessNode(const class ASN1_TypeRefs& Me);
  AccessNode(const class SuiteStructure& Me);
  AccessNode(const class VariationReference& Me);
  AccessNode(const class TS_ParId& Me);
  AccessNode(const class NullType& Me);
  AccessNode(const class Min& Me);
  AccessNode(const class NamedTypeOrSelection& Me);
  AccessNode(const class CM_ParId& Me);
  AccessNode(const class Mantissa& Me);
  AccessNode(const class R_Value& Me);
  AccessNode(const class CM_Constraints& Me);
  AccessNode(const class AliasDefs& Me);
  AccessNode(const class PCO_TypeDcls& Me);
  AccessNode(const class SimpleTypeId& Me);
  AccessNode(const class EncVariationId& Me);
  AccessNode(const class SO_TestCaseId& Me);
  AccessNode(const class VideotexString& Me);
  AccessNode(const class SubType& Me);
  AccessNode(const class Primary& Me);
  AccessNode(const class DefaultGroup& Me);
  AccessNode(const class ASP_ParId& Me);
  AccessNode(const class TC_VarDclList& Me);
  AccessNode(const class ATrue& Me);
  AccessNode(const class VisibleString& Me);
  AccessNode(const class ContainedSubType& Me);
  AccessNode(const class BooleanValue& Me);
  AccessNode(const class TS_VarDcl& Me);
  AccessNode(const class ASN1_ValueReference& Me);
  AccessNode(const class UsefulType& Me);
  AccessNode(const class AliasId& Me);
  AccessNode(const class ASP_TypeDefs& Me);
  AccessNode(const class BITSTRING& Me);
  AccessNode(const class ChoiceType& Me);
  AccessNode(const class Encoding_TypeList& Me);
  AccessNode(const class DefaultReference& Me);
  AccessNode(const class TS_VarType& Me);
  AccessNode(const class TypeOrPDU& Me);
  AccessNode(const class GeneralString& Me);
  AccessNode(const class Cstring& Me);
  AccessNode(const class ParentType& Me);
  AccessNode(const class ComponentPosition& Me);
  AccessNode(const class EventStatement& Me);
  AccessNode(const class TCompUsed& Me);
  AccessNode(const class LessOrEqual& Me);
  AccessNode(const class Less& Me);
  AccessNode(const class OMIT& Me);
  AccessNode(const class TestStepIdAndParList& Me);
  AccessNode(const class Activate& Me);
  AccessNode(const class ASN1_TypeDef& Me);
  AccessNode(const class RealType& Me);
  AccessNode(const class NamedConstraintList& Me);
  AccessNode(const class SingleTypeConstraint& Me);
  AccessNode(const class ASN1_CM_Constraint& Me);
  AccessNode(const class TS_OpDefs& Me);
  AccessNode(const class Div& Me);
  AccessNode(const class TTCN_PDU_TypeDef& Me);
  AccessNode(const class SO_TestStepId& Me);
  AccessNode(const class Mod& Me);
  AccessNode(const class ValueAttributes& Me);
  AccessNode(const class LowerBound& Me);
  AccessNode(const class PicoSeconds& Me);
  AccessNode(const class FormalParType& Me);
  AccessNode(const class ASN1_ASP_TypeDef& Me);
  AccessNode(const class TimerDcls& Me);
  AccessNode(const class SelectExprId& Me);
  AccessNode(const class SO_SuiteId& Me);
  AccessNode(const class SequenceSubType& Me);
  AccessNode(const class Attach& Me);
  AccessNode(const class TCompConfigDcls& Me);
  AccessNode(const class SO_TestGroupRef& Me);
  AccessNode(const class Minus& Me);
  AccessNode(const class Num_CPs& Me);
  AccessNode(const class SimpleTypeDef& Me);
  AccessNode(const class ImportedObjectList& Me);
  AccessNode(const class PrintableString& Me);
  AccessNode(const class TaggedType& Me);
  AccessNode(const class TestStepAttachment& Me);
  AccessNode(const class NONE& Me);
  AccessNode(const class OCTETSTRING& Me);
  AccessNode(const class ObjIdComponent& Me);
  AccessNode(const class AnyType& Me);
  AccessNode(const class InvalidFieldEncodingDefinition& Me);
  AccessNode(const class AnyOrOmit& Me);
  AccessNode(const class TIMER& Me);
  AccessNode(const class NamedType& Me);
  AccessNode(const class ComponentIdentifier& Me);
  AccessNode(const class TS_ConstValue& Me);
  AccessNode(const class TS_OpDescription& Me);
  AccessNode(const class TS_TypeDefs& Me);
  AccessNode(const class ObjectIdentifierType& Me);
  AccessNode(const class AlternativeTypeList& Me);
  AccessNode(const class UnaryExpression& Me);
  AccessNode(const class TestStepRef& Me);
  AccessNode(const class StartTimer& Me);
  AccessNode(const class ImplicitSend& Me);
  AccessNode(const class PDU_FieldDcls& Me);
  AccessNode(const class StructIdAndFullId& Me);
  AccessNode(const class EncodingVariation& Me);
  AccessNode(const class INFINITY& Me);
  AccessNode(const class DefinedValue& Me);
  AccessNode(const class CM_ParDcls& Me);
  AccessNode(const class SourceName& Me);
  AccessNode(const class ASN1_TypeRef& Me);
  AccessNode(const class ASN1_TypeAndLocalTypes& Me);
  AccessNode(const class TestGroupOrTestCaseList& Me);
  AccessNode(const class MacroSymbol& Me);
  AccessNode(const class ASN1_LocalTypes& Me);
  AccessNode(const class ASN1_CM_TypeDefs& Me);
  AccessNode(const class ASP_IdAndFullId& Me);
  AccessNode(const class NumOf_PCOs& Me);
  AccessNode(const class SO_PICSRef& Me);
  AccessNode(const class DetailedComment& Me);
  AccessNode(const class Greater& Me);
  AccessNode(const class UTCTime& Me);
  AccessNode(const class TCompConfigId& Me);
  AccessNode(const class SO_PIXITRef& Me);
  AccessNode(const class SimpleValue& Me);
  AccessNode(const class SelectExprDefs& Me);
  AccessNode(const class EncodingDefs& Me);
  AccessNode(const class TS_ProcResult& Me);
  AccessNode(const class TreeHeader& Me);
  AccessNode(const class TestGroupOrTestCase& Me);
  AccessNode(const class PCO_Id& Me);
  AccessNode(const class TS_ConstId& Me);
  AccessNode(const class IntegerRange& Me);
  AccessNode(const class CompactTestCaseList& Me);
  AccessNode(const class ASN1_ModuleId& Me);
  AccessNode(const class ElemIdAndFullId& Me);
  AccessNode(const class INTEGER& Me);
  AccessNode(const class Line& Me);
  AccessNode(const class TTCN_PDU_Constraints& Me);
  AccessNode(const class PCO_TypeDcl& Me);
  AccessNode(const class TS_ConstRefs& Me);
  AccessNode(const class SingleLength& Me);
  AccessNode(const class UpperTypeBound& Me);
  AccessNode(const class LowerTypeBound& Me);
  AccessNode(const class ComponentNumber& Me);
  AccessNode(const class DefaultRef& Me);
  AccessNode(const class ASN1_PDU_Constraint& Me);
  AccessNode(const class TTCN_ASP_TypeDefs& Me);
  AccessNode(const class PCO_Dcl& Me);
  AccessNode(const class APPLICATION& Me);
  AccessNode(const class FormalParList& Me);
  AccessNode(const class SelectionValue& Me);
  AccessNode(const class SequenceOfValue& Me);
  AccessNode(const class CreateTComp& Me);
  AccessNode(const class ASP_ParDcl& Me);
  AccessNode(const class Duration& Me);
  AccessNode(const class TCompConfigDcl& Me);
  AccessNode(const class TS_VarDcls& Me);
  AccessNode(const class OctetStringType& Me);
  AccessNode(const class ASN1_PDU_TypeDefByRef& Me);
  AccessNode(const class TS_OpResult& Me);
  AccessNode(const class InvalidFieldEncodingCall& Me);
  AccessNode(const class ASP_Constraints& Me);
  AccessNode(const class EncRuleId& Me);
  AccessNode(const class InvalidFieldEncodingDef& Me);
  AccessNode(const class Imports& Me);
  AccessNode(const class TeletexString& Me);
  AccessNode(const class Create& Me);
  AccessNode(const class TestCaseId& Me);
  AccessNode(const class ASN1_ASP_TypeDefByRefList& Me);
  AccessNode(const class TCompId& Me);
  AccessNode(const class PTC& Me);
  AccessNode(const class PRESENT& Me);
  AccessNode(const class DefaultValue& Me);
  AccessNode(const class Exponent& Me);
  AccessNode(const class ValueRange& Me);
  AccessNode(const class IdOrNum& Me);
  AccessNode(const class DeclarationsPart& Me);
  AccessNode(const class ReferenceType& Me);
  AccessNode(const class EncodingVariationSet& Me);
  AccessNode(const class Plus& Me);
  AccessNode(const class TestStepGroupReference& Me);
  AccessNode(const class InnerTypeConstraints& Me);
  AccessNode(const class Omit& Me);
  AccessNode(const class ConstraintExpression& Me);
  AccessNode(const class ConsRef& Me);
  AccessNode(const class CompactTestGroup& Me);
  AccessNode(const class EncodingDefList& Me);
  AccessNode(const class TS_ParDcl& Me);
  AccessNode(const class AnyValue& Me);
  AccessNode(const class DefinedType& Me);
  AccessNode(const class TTCN_PDU_Constraint& Me);
  AccessNode(const class TCompConfigInfoList& Me);
  AccessNode(const class UT& Me);
  AccessNode(const class PRIVATE_& Me);
  AccessNode(const class Tag& Me);
  AccessNode(const class MultExpression& Me);
  AccessNode(const class UpperRangeBound& Me);
  AccessNode(const class SO_DefIndexList& Me);
  AccessNode(const class EncodingReference& Me);
  AccessNode(const class BitRef& Me);
  AccessNode(const class UnaryOp& Me);
  AccessNode(const class ASP_ParIdAndFullId& Me);
  AccessNode(const class TimerId& Me);
  AccessNode(const class TimerDcl& Me);
  AccessNode(const class P_Role& Me);
  AccessNode(const class TS_ParType& Me);
  AccessNode(const class FullIdentifier& Me);
  AccessNode(const class EncVariationIdAndParList& Me);
  AccessNode(const class ObjectDescriptor& Me);
  AccessNode(const class T61String& Me);
  AccessNode(const class ObjectIdentifierValue& Me);
  AccessNode(const class LowerValueBound& Me);
  AccessNode(const class PCO_TypeId& Me);
  AccessNode(const class TestCaseIndex& Me);
  AccessNode(const class Constraint& Me);
  AccessNode(const class SizeConstraint& Me);
  AccessNode(const class ASN1_ASP_Constraint& Me);
  AccessNode(const class ASP_Id& Me);
  AccessNode(const class SimpleTypeDefinition& Me);
  AccessNode(const class IntegerType& Me);
  AccessNode(const class ArrayRefOrComp& Me);
  AccessNode(const class CM_TypeDefs& Me);
  AccessNode(const class NameAndNumberForm& Me);
  AccessNode(const class SetOfType& Me);
  AccessNode(const class Factor& Me);
  AccessNode(const class TestStepId& Me);
  AccessNode(const class BehaviourLine& Me);
  AccessNode(const class Children& Me);
  AccessNode(const class Objective& Me);
  AccessNode(const class ValueList& Me);
  AccessNode(const class CP_DclList& Me);
  AccessNode(const class SuiteOverviewPart& Me);
  AccessNode(const class ANYValue& Me);
  AccessNode(const class MultOp& Me);
  AccessNode(const class ASN1_PDU_TypeDef& Me);
  AccessNode(const class VariationDefault& Me);
  AccessNode(const class IF_PRESENT& Me);
  AccessNode(const class ASN1_ASP_Constraints& Me);
  AccessNode(const class CM_ParIdOrMacro& Me);
  AccessNode(const class Or& Me);
  AccessNode(const class DefaultCase& Me);
  AccessNode(const class TestStepGroup& Me);
  AccessNode(const class StructTypeConstraints& Me);
  AccessNode(const class CP_Id& Me);
  AccessNode(const class ASN1_TypeRefList& Me);
  AccessNode(const class StructTypeDef& Me);
  AccessNode(const class TestGroupReference& Me);
  AccessNode(const class Base& Me);
  AccessNode(const class NameForm& Me);
  AccessNode(const class TTCN_ASP_Constraint& Me);
  AccessNode(const class FormalParIdList& Me);
  AccessNode(const class NamedNumberList& Me);
  AccessNode(const class PDU_FieldDcl& Me);
  AccessNode(const class EncodingRuleId& Me);
  AccessNode(const class ElemDcl& Me);
  AccessNode(const class LocalTree& Me);
  AccessNode(const class ReferenceList& Me);
  AccessNode(const class TimeUnit& Me);
  AccessNode(const class NotEqual& Me);
  AccessNode(const class NamedConstraint& Me);
  AccessNode(const class NamedNumber& Me);
  AccessNode(const class PDU_FieldIdOrMacro& Me);
  AccessNode(const class SimpleTypeDefs& Me);
  AccessNode(const class SetValue& Me);
  AccessNode(const class CM_ParIdAndFullId& Me);
  AccessNode(const class PDU_FieldId& Me);
  AccessNode(const class TC_VarId& Me);
  AccessNode(const class Hstring& Me);
  AccessNode(const class LowerEndValue& Me);
  AccessNode(const class Declarations& Me);
  AccessNode(const class TestStepIndex& Me);
  AccessNode(const class TypeAndLengthAttribute& Me);
  AccessNode(const class NanoSeconds& Me);
  AccessNode(const class NamedTypeAttribute& Me);
  AccessNode(const class Expansion& Me);
  AccessNode(const class ComponentReferenceList& Me);
  AccessNode(const class RootTree& Me);
  AccessNode(const class Description& Me);
  AccessNode(const class NumOf_CPs& Me);
  AccessNode(const class SO_StepIndexList& Me);
  AccessNode(const class ElemType& Me);
  AccessNode(const class R& Me);
  AccessNode(const class Minutes& Me);
  AccessNode(const class IdentifierList& Me);
  AccessNode(const class TypeReference& Me);
  AccessNode(const class ActualCrefParList& Me);
  AccessNode(const class SelExprId& Me);
  AccessNode(const class ASN1_TypeConstraint& Me);
  AccessNode(const class DerivationPath& Me);
  AccessNode(const class TCompDclList& Me);
  AccessNode(const class TS_ProcIdAndParList& Me);
  AccessNode(const class SequenceType& Me);
  AccessNode(const class ASP_ParType& Me);
  AccessNode(const class PDU_FieldEncoding& Me);
  AccessNode(const class INCONC& Me);
  AccessNode(const class UNIVERSAL& Me);
  AccessNode(const class DefaultRefList& Me);
  AccessNode(const class ASP_ParValue& Me);
  AccessNode(const class TC_VarValue& Me);
  AccessNode(const class TC_VarType& Me);
  AccessNode(const class EncodingDefinition& Me);
  AccessNode(const class ASN1_TypeReference& Me);
  AccessNode(const class Not& Me);
  AccessNode(const class Ten& Me);
  AccessNode(const class NumericRealValue& Me);
  AccessNode(const class TypeAssignmentList& Me);
  AccessNode(const class DynamicPart& Me);
  AccessNode(const class AliasDefList& Me);
  AccessNode(const class CP_List& Me);
  AccessNode(const class CPs_Used& Me);
  AccessNode(const class OmitReference& Me);
  AccessNode(const class TTCN_CM_TypeDef& Me);
  AccessNode(const class TS_ConstDclList& Me);
  AccessNode(const class LengthRestriction& Me);
  AccessNode(const class TS_ParDcls& Me);
  AccessNode(const class TestStepGroupId& Me);
  AccessNode(const class CP_Dcl& Me);
  AccessNode(const class TS_VarDclList& Me);
  AccessNode(const class RealValue& Me);
  AccessNode(const class TCompDcls& Me);
  AccessNode(const class DeclarationValue& Me);
  AccessNode(const class SelectionExpression& Me);
  AccessNode(const class PredefinedType& Me);
  AccessNode(const class BooleanType& Me);
  AccessNode(const class Send& Me);
  AccessNode(const class ASN1_CM_TypeDef& Me);
  AccessNode(const class ConstraintValueAndAttributesOrReplace& Me);
  AccessNode(const class InvalidFieldEncodingIdAndParList& Me);
  AccessNode(const class ConstraintValueAndAttributes& Me);
  AccessNode(const class Qualifier& Me);
  AccessNode(const class PDU_IdAndFullId& Me);
  AccessNode(const class CP_Dcls& Me);
  AccessNode(const class SelectExprDef& Me);
  AccessNode(const class CharacterString& Me);
  AccessNode(const class ISO646String& Me);
  AccessNode(const class TypeAssignment& Me);
  AccessNode(const class ParenExpression& Me);
  AccessNode(const class DefaultId& Me);
  AccessNode(const class TestStep& Me);
  AccessNode(const class CreateList& Me);
  AccessNode(const class ConstraintsPart& Me);
  AccessNode(const class ASN1_PDU_TypeDefs& Me);
  AccessNode(const class NumericString& Me);
  AccessNode(const class BitIdentifier& Me);
  AccessNode(const class MatchingSymbol& Me);
  AccessNode(const class TestGroupRef& Me);
  AccessNode(const class TimerDclList& Me);
  AccessNode(const class TS_ParDclList& Me);
  AccessNode(const class FormalParAndType& Me);
  AccessNode(const class ReplacementList& Me);
  AccessNode(const class Minus_INFINITY& Me);
  AccessNode(const class GraphicString& Me);
  AccessNode(const class ElementTypeList& Me);
  AccessNode(const class AddExpression& Me);
  AccessNode(const class RETURN_& Me);
  AccessNode(const class LT& Me);
  AccessNode(const class Identifier& Me);
  AccessNode(const class PresenceConstraint& Me);
  AccessNode(const class ComponentReference& Me);
  AccessNode(const class SingleValueLength& Me);
  AccessNode(const class TestGroupId& Me);
  AccessNode(const class GoTo& Me);
  AccessNode(const class TS_OpId& Me);
  AccessNode(const class ASuite& Me);
  AccessNode(const class FAIL& Me);
  AccessNode(const class Plus_INFINITY& Me);
  AccessNode(const class SimpleExpression& Me);
  AccessNode(const class ConsValue& Me);
  AccessNode(const class TS_ConstDcl& Me);
  AccessNode(const class SO_StandardsRef& Me);
  AccessNode(const class EncVariationCall& Me);
  AccessNode(const class AFalse& Me);
  AccessNode(const class PreliminaryFAIL& Me);
  AccessNode(const class OpCall& Me);
  AccessNode(const class SuperSet& Me);
  AccessNode(const class LowerRangeBound& Me);
  AccessNode(const class TimerOp& Me);
  AccessNode(const class ElemValue& Me);
  AccessNode(const class SourceRef& Me);
  AccessNode(const class UpperEndValue& Me);
  AccessNode(const class SubTypeSpec& Me);
  AccessNode(const class Term& Me);
  AccessNode(const class PDU_Constraints& Me);
  AccessNode(const class PCO_Role& Me);
  AccessNode(const class ElementValueList& Me);
  AccessNode(const class SequenceValue& Me);
  AccessNode(const class SequenceOfType& Me);
  AccessNode(const class EncodingDefault& Me);
  AccessNode(const class TestStepGroupOrTestStep& Me);
  AccessNode(const class WithComponents& Me);
  AccessNode(const class BehaviourDescription& Me);
  AccessNode(const class CompactTestCase& Me);
  AccessNode(const class CM_ParValue& Me);
  AccessNode(const class TTCN_CM_Constraint& Me);
  AccessNode(const class PDU_TypeDefs& Me);
  AccessNode(const class TCompDcl& Me);
  AccessNode(const class TS_ConstType& Me);
  AccessNode(const class ElemDcls& Me);
  AccessNode(const class LengthAttribute& Me);
  AccessNode(const class Permutation& Me);
  AccessNode(const class DefaultsLibrary& Me);
  AccessNode(const class DerivPath& Me);
  AccessNode(const class ImportPart& Me);
  AccessNode(const class PASS& Me);
  AccessNode(const class MTC& Me);
  AccessNode(const class SubtypeValueSet& Me);
  AccessNode(const class EnumeratedType& Me);
  AccessNode(const class DefaultGroupOrDefaultList& Me);
  AccessNode(const class Otherwise& Me);
  AccessNode(const class LabelId& Me);
  AccessNode(const class TTCN_CM_Constraints& Me);
  AccessNode(const class ASN1_ASP_TypeDefsByRef& Me);
  AccessNode(const class ASP_ParDcls& Me);
  AccessNode(const class Num_PCOs& Me);
  AccessNode(const class PreliminaryINCONC& Me);
  AccessNode(const class PreliminaryPASS& Me);
  AccessNode(const class ABSENT& Me);
  AccessNode(const class Done& Me);
  AccessNode(const class TC_VarDcls& Me);
  AccessNode(const class TS_VarValue& Me);
  AccessNode(const class TS_ProcDescription& Me);
  AccessNode(const class EncodingDefinitions& Me);
  AccessNode(const class SingleTypeLength& Me);
  AccessNode(const class IA5String& Me);
  AccessNode(const class Ostring& Me);
  AccessNode(const class RangeValueLength& Me);
  AccessNode(const class Verdict& Me);
  AccessNode(const class ASN1_PDU_TypeDefsByRef& Me);
  AccessNode(const class PDU_Id& Me);
  AccessNode(const class ComplexDefinitions& Me);
  AccessNode(const class SelectExprDefList& Me);
  AccessNode(const class ASN1_TypeDefinition& Me);
  AccessNode(const class SubSet& Me);
  AccessNode(const class Complement& Me);
  AccessNode(const class VerdictId& Me);
  AccessNode(const class DefaultsRef& Me);
  AccessNode(const class Bstring& Me);
  AccessNode(const class TagAttributes& Me);
  AccessNode(const class ActualParList& Me);
  AccessNode(const class ValueLength& Me);
  AccessNode(const class TestStepGroupOrTestStepList& Me);
  AccessNode(const class Cref& Me);
  AccessNode(const class TimerOps& Me);
  AccessNode(const class TestCase& Me);
  AccessNode(const class ASN1_TypeConstraints& Me);
  AccessNode(const class CM_ParDcl& Me);
  AccessNode(const class ASN1_Type& Me);
  AccessNode(const class TimerValue& Me);
  AccessNode(const class PDU_FieldValue& Me);
  AccessNode(const class TS_ConstRef& Me);
  AccessNode(const class EXTERNAL& Me);
  AccessNode(const class Indentation& Me);
  AccessNode(const class TypeConstraints& Me);
  AccessNode(const class LiteralValue& Me);
  AccessNode(const class StatementLine& Me);
  AccessNode(const class SO_TestStepRef& Me);
  AccessNode(const class HEXSTRING& Me);
  AccessNode(const class NamedTypeAndAttributes& Me);
  AccessNode(const class ConstraintReference& Me);
  AccessNode(const class ASN1_PDU_Constraints& Me);
  AccessNode(const class ConsIdAndParList& Me);
  AccessNode(const class SO_Objective& Me);
  AccessNode(const class ParamAndSelection& Me);
  AccessNode(const class Receive& Me);
  AccessNode(const class ASN1_CM_Constraints& Me);
  AccessNode(const class PCO_Type& Me);
  AccessNode(const class TComp_Role& Me);
  AccessNode(const class Definitions& Me);
  AccessNode(const class Seconds& Me);
  AccessNode(const class ValueConstraint& Me);
  AccessNode(const class DataObjectReference& Me);
  AccessNode(const class AliasDef& Me);
  AccessNode(const class AIMPLICIT& Me);
  AccessNode(const class BitStringValue& Me);
  AccessNode(const class Value& Me);
  AccessNode(const class RelOp& Me);
  AccessNode(const class RelExpression& Me);
  AccessNode(const class LineNumber& Me);
  AccessNode(const class Number& Me);
  AccessNode(const class TypeAndRestriction& Me);
  AccessNode(const class TS_OpIdAndParList& Me);
  AccessNode(const class LowerEndpoint& Me);
  AccessNode(const class ASN1_Value& Me);
  AccessNode(const class CancelTimer& Me);
  AccessNode(const class ImportDeclarations& Me);
  AccessNode(const class BOOLEAN& Me);
  AccessNode(const class Replace& Me);
  AccessNode(const class TCompConfigInfo& Me);
  AccessNode(const class SO_CaseIndex& Me);
  AccessNode(const class TS_OpDef& Me);
  AccessNode(const class ConstraintValue& Me);
  AccessNode(const class SO_StructureAndObjective& Me);
  AccessNode(const class PDU_FieldEncodingCall& Me);
  AccessNode(const class FullSpecification& Me);
  AccessNode(const class UpperEndpoint& Me);
  AccessNode(const class PermittedAlphabet& Me);
  AccessNode(const class BitStringType& Me);
  AccessNode(const class TreeReference& Me);
  AccessNode(const class MicroSeconds& Me);
  AccessNode(const class Fail& Me);
  AccessNode(const class StructTypeConstraint& Me);
  AccessNode(const class ASN1_ASP_TypeDefByRef& Me);
  AccessNode(const class Restriction& Me);
  AccessNode(const class EncodingRef& Me);
  AccessNode(const class SO_DefIndex& Me);
  AccessNode(const class Construct& Me);
  AccessNode(const class Unit& Me);
  AccessNode(const class TS_ConstDcls& Me);
  AccessNode(const class MilliSeconds& Me);
  AccessNode(const class CP& Me);
  AccessNode(const class TTCN_PDU_TypeDefs& Me);
  AccessNode(const class PCO_TypeDclList& Me);
  AccessNode(const class EncodingVariationList& Me);
  AccessNode(const class INCLUSIVE& Me);
  AccessNode(const class SetType& Me);
  AccessNode(const class SO_SelExprId& Me);
  AccessNode(const class Bound& Me);
  AccessNode(const class GeneralizedTime& Me);
  AccessNode(const class DefaultGroupId& Me);
  AccessNode(const class RangeLength& Me);
  AccessNode(const class SimpleTypeDefList& Me);
  AccessNode(const class SO_CaseIndexList& Me);


  const class MultipleTypeConstraints* MultipleTypeConstraints() const;
  const class TS_ConstRefList* TS_ConstRefList() const;
  const class InvalidFieldEncodingDefs* InvalidFieldEncodingDefs() const;
  const class AEXPLICIT* AEXPLICIT() const;
  const class AnyDefinedBy* AnyDefinedBy() const;
  const class ValueBound* ValueBound() const;
  const class Pass* Pass() const;
  const class CM_Id* CM_Id() const;
  const class PCO_List* PCO_List() const;
  const class TC_VarDcl* TC_VarDcl() const;
  const class RecordRef* RecordRef() const;
  const class TTCN_Type* TTCN_Type() const;
  const class SO_StructureAndObjectives* SO_StructureAndObjectives() const;
  const class R_TYPE* R_TYPE() const;
  const class ParentSubType* ParentSubType() const;
  const class VariationRef* VariationRef() const;
  const class TS_ProcId* TS_ProcId() const;
  const class Configuration* Configuration() const;
  const class SO_StepIndex* SO_StepIndex() const;
  const class Mult* Mult() const;
  const class BuiltinType* BuiltinType() const;
  const class CM_ParValues* CM_ParValues() const;
  const class ExpandedId* ExpandedId() const;
  const class ASN1_TypeDefs* ASN1_TypeDefs() const;
  const class ArrayRef* ArrayRef() const;
  const class TestGroup* TestGroup() const;
  const class TS_VarId* TS_VarId() const;
  const class TS_ProcDefs* TS_ProcDefs() const;
  const class ASN1_ValueList* ASN1_ValueList() const;
  const class ASN1_PDU_TypeDefByRefList* ASN1_PDU_TypeDefByRefList() const;
  const class PCO_Dcls* PCO_Dcls() const;
  const class ASP_ParValues* ASP_ParValues() const;
  const class EncodingVariations* EncodingVariations() const;
  const class SpecialRealValue* SpecialRealValue() const;
  const class ReadTimer* ReadTimer() const;
  const class ObjectName* ObjectName() const;
  const class PartialSpecification* PartialSpecification() const;
  const class TCompIdList* TCompIdList() const;
  const class Event* Event() const;
  const class PDU_FieldValues* PDU_FieldValues() const;
  const class TTCN_ASP_TypeDef* TTCN_ASP_TypeDef() const;
  const class InvalidFieldEncodingId* InvalidFieldEncodingId() const;
  const class Max* Max() const;
  const class Inconclusive* Inconclusive() const;
  const class PICS_PIXITref* PICS_PIXITref() const;
  const class ObjIdComponentList* ObjIdComponentList() const;
  const class DefaultGroupOrDefault* DefaultGroupOrDefault() const;
  const class Result* Result() const;
  const class ASP_ParIdOrMacro* ASP_ParIdOrMacro() const;
  const class PCO_DclList* PCO_DclList() const;
  const class TC_Role* TC_Role() const;
  const class StructId* StructId() const;
  const class MinusINFINITY* MinusINFINITY() const;
  const class NullValue* NullValue() const;
  const class TestStepLibrary* TestStepLibrary() const;
  const class NumberForm* NumberForm() const;
  const class ClassType* ClassType() const;
  const class Label* Label() const;
  const class Replacement* Replacement() const;
  const class TTCN_ASP_Constraints* TTCN_ASP_Constraints() const;
  const class SimpleValueList* SimpleValueList() const;
  const class Comment* Comment() const;
  const class UpperValueBound* UpperValueBound() const;
  const class Assignment* Assignment() const;
  const class TestCases* TestCases() const;
  const class ImportedObject* ImportedObject() const;
  const class SO_Description* SO_Description() const;
  const class SingleValue* SingleValue() const;
  const class DefaultExpression* DefaultExpression() const;
  const class ASN1_ConsValue* ASN1_ConsValue() const;
  const class TS_TypeConstraints* TS_TypeConstraints() const;
  const class And* And() const;
  const class NamedValue* NamedValue() const;
  const class LocalTreeList* LocalTreeList() const;
  const class EncodingVariationId* EncodingVariationId() const;
  const class Expression* Expression() const;
  const class TTCN_CM_TypeDefs* TTCN_CM_TypeDefs() const;
  const class SignedNumber* SignedNumber() const;
  const class Header* Header() const;
  const class CreateAttach* CreateAttach() const;
  const class TestPurpose* TestPurpose() const;
  const class RangeTypeLength* RangeTypeLength() const;
  const class TS_ProcDef* TS_ProcDef() const;
  const class TypeAndAttributes* TypeAndAttributes() const;
  const class Two* Two() const;
  const class SetOfValue* SetOfValue() const;
  const class DefaultIndex* DefaultIndex() const;
  const class UpperBound* UpperBound() const;
  const class PDU* PDU() const;
  const class ANY* ANY() const;
  const class DefaultGroupReference* DefaultGroupReference() const;
  const class Enumeration* Enumeration() const;
  const class SelectionType* SelectionType() const;
  const class AssignmentList* AssignmentList() const;
  const class BehaviourLineList* BehaviourLineList() const;
  const class PDU_FieldIdAndFullId* PDU_FieldIdAndFullId() const;
  const class PDU_EncodingId* PDU_EncodingId() const;
  const class SetSubType* SetSubType() const;
  const class ElementType* ElementType() const;
  const class Timeout* Timeout() const;
  const class ASN1_ASP_TypeDefs* ASN1_ASP_TypeDefs() const;
  const class SelectExpr* SelectExpr() const;
  const class SO_DefaultId* SO_DefaultId() const;
  const class StructTypeDefs* StructTypeDefs() const;
  const class ComponentsOf* ComponentsOf() const;
  const class BitNumber* BitNumber() const;
  const class AddOp* AddOp() const;
  const class ValRange* ValRange() const;
  const class ASN1_TypeId* ASN1_TypeId() const;
  const class ElemId* ElemId() const;
  const class SO_TestMethods* SO_TestMethods() const;
  const class Equal* Equal() const;
  const class WithComponent* WithComponent() const;
  const class ClassNumber* ClassNumber() const;
  const class NamedBitList* NamedBitList() const;
  const class Repeat* Repeat() const;
  const class SuiteId* SuiteId() const;
  const class GreaterOrEqual* GreaterOrEqual() const;
  const class OPTIONAL* OPTIONAL() const;
  const class PDU_FieldType* PDU_FieldType() const;
  const class PCOs_Used* PCOs_Used() const;
  const class SO_DefaultRef* SO_DefaultRef() const;
  const class ObjectType* ObjectType() const;
  const class DefaultIdAndParList* DefaultIdAndParList() const;
  const class CM_ParType* CM_ParType() const;
  const class ChoiceValue* ChoiceValue() const;
  const class ElemValues* ElemValues() const;
  const class ConsId* ConsId() const;
  const class ASN1_TypeRefs* ASN1_TypeRefs() const;
  const class SuiteStructure* SuiteStructure() const;
  const class VariationReference* VariationReference() const;
  const class TS_ParId* TS_ParId() const;
  const class NullType* NullType() const;
  const class Min* Min() const;
  const class NamedTypeOrSelection* NamedTypeOrSelection() const;
  const class CM_ParId* CM_ParId() const;
  const class Mantissa* Mantissa() const;
  const class R_Value* R_Value() const;
  const class CM_Constraints* CM_Constraints() const;
  const class AliasDefs* AliasDefs() const;
  const class PCO_TypeDcls* PCO_TypeDcls() const;
  const class SimpleTypeId* SimpleTypeId() const;
  const class EncVariationId* EncVariationId() const;
  const class SO_TestCaseId* SO_TestCaseId() const;
  const class VideotexString* VideotexString() const;
  const class SubType* SubType() const;
  const class Primary* Primary() const;
  const class DefaultGroup* DefaultGroup() const;
  const class ASP_ParId* ASP_ParId() const;
  const class TC_VarDclList* TC_VarDclList() const;
  const class ATrue* ATrue() const;
  const class VisibleString* VisibleString() const;
  const class ContainedSubType* ContainedSubType() const;
  const class BooleanValue* BooleanValue() const;
  const class TS_VarDcl* TS_VarDcl() const;
  const class ASN1_ValueReference* ASN1_ValueReference() const;
  const class UsefulType* UsefulType() const;
  const class AliasId* AliasId() const;
  const class ASP_TypeDefs* ASP_TypeDefs() const;
  const class BITSTRING* BITSTRING() const;
  const class ChoiceType* ChoiceType() const;
  const class Encoding_TypeList* Encoding_TypeList() const;
  const class DefaultReference* DefaultReference() const;
  const class TS_VarType* TS_VarType() const;
  const class TypeOrPDU* TypeOrPDU() const;
  const class GeneralString* GeneralString() const;
  const class Cstring* Cstring() const;
  const class ParentType* ParentType() const;
  const class ComponentPosition* ComponentPosition() const;
  const class EventStatement* EventStatement() const;
  const class TCompUsed* TCompUsed() const;
  const class LessOrEqual* LessOrEqual() const;
  const class Less* Less() const;
  const class OMIT* OMIT() const;
  const class TestStepIdAndParList* TestStepIdAndParList() const;
  const class Activate* Activate() const;
  const class ASN1_TypeDef* ASN1_TypeDef() const;
  const class RealType* RealType() const;
  const class NamedConstraintList* NamedConstraintList() const;
  const class SingleTypeConstraint* SingleTypeConstraint() const;
  const class ASN1_CM_Constraint* ASN1_CM_Constraint() const;
  const class TS_OpDefs* TS_OpDefs() const;
  const class Div* Div() const;
  const class TTCN_PDU_TypeDef* TTCN_PDU_TypeDef() const;
  const class SO_TestStepId* SO_TestStepId() const;
  const class Mod* Mod() const;
  const class ValueAttributes* ValueAttributes() const;
  const class LowerBound* LowerBound() const;
  const class PicoSeconds* PicoSeconds() const;
  const class FormalParType* FormalParType() const;
  const class ASN1_ASP_TypeDef* ASN1_ASP_TypeDef() const;
  const class TimerDcls* TimerDcls() const;
  const class SelectExprId* SelectExprId() const;
  const class SO_SuiteId* SO_SuiteId() const;
  const class SequenceSubType* SequenceSubType() const;
  const class Attach* Attach() const;
  const class TCompConfigDcls* TCompConfigDcls() const;
  const class SO_TestGroupRef* SO_TestGroupRef() const;
  const class Minus* Minus() const;
  const class Num_CPs* Num_CPs() const;
  const class SimpleTypeDef* SimpleTypeDef() const;
  const class ImportedObjectList* ImportedObjectList() const;
  const class PrintableString* PrintableString() const;
  const class TaggedType* TaggedType() const;
  const class TestStepAttachment* TestStepAttachment() const;
  const class NONE* NONE() const;
  const class OCTETSTRING* OCTETSTRING() const;
  const class ObjIdComponent* ObjIdComponent() const;
  const class AnyType* AnyType() const;
  const class InvalidFieldEncodingDefinition* InvalidFieldEncodingDefinition() const;
  const class AnyOrOmit* AnyOrOmit() const;
  const class TIMER* TIMER() const;
  const class NamedType* NamedType() const;
  const class ComponentIdentifier* ComponentIdentifier() const;
  const class TS_ConstValue* TS_ConstValue() const;
  const class TS_OpDescription* TS_OpDescription() const;
  const class TS_TypeDefs* TS_TypeDefs() const;
  const class ObjectIdentifierType* ObjectIdentifierType() const;
  const class AlternativeTypeList* AlternativeTypeList() const;
  const class UnaryExpression* UnaryExpression() const;
  const class TestStepRef* TestStepRef() const;
  const class StartTimer* StartTimer() const;
  const class ImplicitSend* ImplicitSend() const;
  const class PDU_FieldDcls* PDU_FieldDcls() const;
  const class StructIdAndFullId* StructIdAndFullId() const;
  const class EncodingVariation* EncodingVariation() const;
  const class INFINITY* INFINITY() const;
  const class DefinedValue* DefinedValue() const;
  const class CM_ParDcls* CM_ParDcls() const;
  const class SourceName* SourceName() const;
  const class ASN1_TypeRef* ASN1_TypeRef() const;
  const class ASN1_TypeAndLocalTypes* ASN1_TypeAndLocalTypes() const;
  const class TestGroupOrTestCaseList* TestGroupOrTestCaseList() const;
  const class MacroSymbol* MacroSymbol() const;
  const class ASN1_LocalTypes* ASN1_LocalTypes() const;
  const class ASN1_CM_TypeDefs* ASN1_CM_TypeDefs() const;
  const class ASP_IdAndFullId* ASP_IdAndFullId() const;
  const class NumOf_PCOs* NumOf_PCOs() const;
  const class SO_PICSRef* SO_PICSRef() const;
  const class DetailedComment* DetailedComment() const;
  const class Greater* Greater() const;
  const class UTCTime* UTCTime() const;
  const class TCompConfigId* TCompConfigId() const;
  const class SO_PIXITRef* SO_PIXITRef() const;
  const class SimpleValue* SimpleValue() const;
  const class SelectExprDefs* SelectExprDefs() const;
  const class EncodingDefs* EncodingDefs() const;
  const class TS_ProcResult* TS_ProcResult() const;
  const class TreeHeader* TreeHeader() const;
  const class TestGroupOrTestCase* TestGroupOrTestCase() const;
  const class PCO_Id* PCO_Id() const;
  const class TS_ConstId* TS_ConstId() const;
  const class IntegerRange* IntegerRange() const;
  const class CompactTestCaseList* CompactTestCaseList() const;
  const class ASN1_ModuleId* ASN1_ModuleId() const;
  const class ElemIdAndFullId* ElemIdAndFullId() const;
  const class INTEGER* INTEGER() const;
  const class Line* Line() const;
  const class TTCN_PDU_Constraints* TTCN_PDU_Constraints() const;
  const class PCO_TypeDcl* PCO_TypeDcl() const;
  const class TS_ConstRefs* TS_ConstRefs() const;
  const class SingleLength* SingleLength() const;
  const class UpperTypeBound* UpperTypeBound() const;
  const class LowerTypeBound* LowerTypeBound() const;
  const class ComponentNumber* ComponentNumber() const;
  const class DefaultRef* DefaultRef() const;
  const class ASN1_PDU_Constraint* ASN1_PDU_Constraint() const;
  const class TTCN_ASP_TypeDefs* TTCN_ASP_TypeDefs() const;
  const class PCO_Dcl* PCO_Dcl() const;
  const class APPLICATION* APPLICATION() const;
  const class FormalParList* FormalParList() const;
  const class SelectionValue* SelectionValue() const;
  const class SequenceOfValue* SequenceOfValue() const;
  const class CreateTComp* CreateTComp() const;
  const class ASP_ParDcl* ASP_ParDcl() const;
  const class Duration* Duration() const;
  const class TCompConfigDcl* TCompConfigDcl() const;
  const class TS_VarDcls* TS_VarDcls() const;
  const class OctetStringType* OctetStringType() const;
  const class ASN1_PDU_TypeDefByRef* ASN1_PDU_TypeDefByRef() const;
  const class TS_OpResult* TS_OpResult() const;
  const class InvalidFieldEncodingCall* InvalidFieldEncodingCall() const;
  const class ASP_Constraints* ASP_Constraints() const;
  const class EncRuleId* EncRuleId() const;
  const class InvalidFieldEncodingDef* InvalidFieldEncodingDef() const;
  const class Imports* Imports() const;
  const class TeletexString* TeletexString() const;
  const class Create* Create() const;
  const class TestCaseId* TestCaseId() const;
  const class ASN1_ASP_TypeDefByRefList* ASN1_ASP_TypeDefByRefList() const;
  const class TCompId* TCompId() const;
  const class PTC* PTC() const;
  const class PRESENT* PRESENT() const;
  const class DefaultValue* DefaultValue() const;
  const class Exponent* Exponent() const;
  const class ValueRange* ValueRange() const;
  const class IdOrNum* IdOrNum() const;
  const class DeclarationsPart* DeclarationsPart() const;
  const class ReferenceType* ReferenceType() const;
  const class EncodingVariationSet* EncodingVariationSet() const;
  const class Plus* Plus() const;
  const class TestStepGroupReference* TestStepGroupReference() const;
  const class InnerTypeConstraints* InnerTypeConstraints() const;
  const class Omit* Omit() const;
  const class ConstraintExpression* ConstraintExpression() const;
  const class ConsRef* ConsRef() const;
  const class CompactTestGroup* CompactTestGroup() const;
  const class EncodingDefList* EncodingDefList() const;
  const class TS_ParDcl* TS_ParDcl() const;
  const class AnyValue* AnyValue() const;
  const class DefinedType* DefinedType() const;
  const class TTCN_PDU_Constraint* TTCN_PDU_Constraint() const;
  const class TCompConfigInfoList* TCompConfigInfoList() const;
  const class UT* UT() const;
  const class PRIVATE_* PRIVATE_() const;
  const class Tag* Tag() const;
  const class MultExpression* MultExpression() const;
  const class UpperRangeBound* UpperRangeBound() const;
  const class SO_DefIndexList* SO_DefIndexList() const;
  const class EncodingReference* EncodingReference() const;
  const class BitRef* BitRef() const;
  const class UnaryOp* UnaryOp() const;
  const class ASP_ParIdAndFullId* ASP_ParIdAndFullId() const;
  const class TimerId* TimerId() const;
  const class TimerDcl* TimerDcl() const;
  const class P_Role* P_Role() const;
  const class TS_ParType* TS_ParType() const;
  const class FullIdentifier* FullIdentifier() const;
  const class EncVariationIdAndParList* EncVariationIdAndParList() const;
  const class ObjectDescriptor* ObjectDescriptor() const;
  const class T61String* T61String() const;
  const class ObjectIdentifierValue* ObjectIdentifierValue() const;
  const class LowerValueBound* LowerValueBound() const;
  const class PCO_TypeId* PCO_TypeId() const;
  const class TestCaseIndex* TestCaseIndex() const;
  const class Constraint* Constraint() const;
  const class SizeConstraint* SizeConstraint() const;
  const class ASN1_ASP_Constraint* ASN1_ASP_Constraint() const;
  const class ASP_Id* ASP_Id() const;
  const class SimpleTypeDefinition* SimpleTypeDefinition() const;
  const class IntegerType* IntegerType() const;
  const class ArrayRefOrComp* ArrayRefOrComp() const;
  const class CM_TypeDefs* CM_TypeDefs() const;
  const class NameAndNumberForm* NameAndNumberForm() const;
  const class SetOfType* SetOfType() const;
  const class Factor* Factor() const;
  const class TestStepId* TestStepId() const;
  const class BehaviourLine* BehaviourLine() const;
  const class Children* Children() const;
  const class Objective* Objective() const;
  const class ValueList* ValueList() const;
  const class CP_DclList* CP_DclList() const;
  const class SuiteOverviewPart* SuiteOverviewPart() const;
  const class ANYValue* ANYValue() const;
  const class MultOp* MultOp() const;
  const class ASN1_PDU_TypeDef* ASN1_PDU_TypeDef() const;
  const class VariationDefault* VariationDefault() const;
  const class IF_PRESENT* IF_PRESENT() const;
  const class ASN1_ASP_Constraints* ASN1_ASP_Constraints() const;
  const class CM_ParIdOrMacro* CM_ParIdOrMacro() const;
  const class Or* Or() const;
  const class DefaultCase* DefaultCase() const;
  const class TestStepGroup* TestStepGroup() const;
  const class StructTypeConstraints* StructTypeConstraints() const;
  const class CP_Id* CP_Id() const;
  const class ASN1_TypeRefList* ASN1_TypeRefList() const;
  const class StructTypeDef* StructTypeDef() const;
  const class TestGroupReference* TestGroupReference() const;
  const class Base* Base() const;
  const class NameForm* NameForm() const;
  const class TTCN_ASP_Constraint* TTCN_ASP_Constraint() const;
  const class FormalParIdList* FormalParIdList() const;
  const class NamedNumberList* NamedNumberList() const;
  const class PDU_FieldDcl* PDU_FieldDcl() const;
  const class EncodingRuleId* EncodingRuleId() const;
  const class ElemDcl* ElemDcl() const;
  const class LocalTree* LocalTree() const;
  const class ReferenceList* ReferenceList() const;
  const class TimeUnit* TimeUnit() const;
  const class NotEqual* NotEqual() const;
  const class NamedConstraint* NamedConstraint() const;
  const class NamedNumber* NamedNumber() const;
  const class PDU_FieldIdOrMacro* PDU_FieldIdOrMacro() const;
  const class SimpleTypeDefs* SimpleTypeDefs() const;
  const class SetValue* SetValue() const;
  const class CM_ParIdAndFullId* CM_ParIdAndFullId() const;
  const class PDU_FieldId* PDU_FieldId() const;
  const class TC_VarId* TC_VarId() const;
  const class Hstring* Hstring() const;
  const class LowerEndValue* LowerEndValue() const;
  const class Declarations* Declarations() const;
  const class TestStepIndex* TestStepIndex() const;
  const class TypeAndLengthAttribute* TypeAndLengthAttribute() const;
  const class NanoSeconds* NanoSeconds() const;
  const class NamedTypeAttribute* NamedTypeAttribute() const;
  const class Expansion* Expansion() const;
  const class ComponentReferenceList* ComponentReferenceList() const;
  const class RootTree* RootTree() const;
  const class Description* Description() const;
  const class NumOf_CPs* NumOf_CPs() const;
  const class SO_StepIndexList* SO_StepIndexList() const;
  const class ElemType* ElemType() const;
  const class R* R() const;
  const class Minutes* Minutes() const;
  const class IdentifierList* IdentifierList() const;
  const class TypeReference* TypeReference() const;
  const class ActualCrefParList* ActualCrefParList() const;
  const class SelExprId* SelExprId() const;
  const class ASN1_TypeConstraint* ASN1_TypeConstraint() const;
  const class DerivationPath* DerivationPath() const;
  const class TCompDclList* TCompDclList() const;
  const class TS_ProcIdAndParList* TS_ProcIdAndParList() const;
  const class SequenceType* SequenceType() const;
  const class ASP_ParType* ASP_ParType() const;
  const class PDU_FieldEncoding* PDU_FieldEncoding() const;
  const class INCONC* INCONC() const;
  const class UNIVERSAL* UNIVERSAL() const;
  const class DefaultRefList* DefaultRefList() const;
  const class ASP_ParValue* ASP_ParValue() const;
  const class TC_VarValue* TC_VarValue() const;
  const class TC_VarType* TC_VarType() const;
  const class EncodingDefinition* EncodingDefinition() const;
  const class ASN1_TypeReference* ASN1_TypeReference() const;
  const class Not* Not() const;
  const class Ten* Ten() const;
  const class NumericRealValue* NumericRealValue() const;
  const class TypeAssignmentList* TypeAssignmentList() const;
  const class DynamicPart* DynamicPart() const;
  const class AliasDefList* AliasDefList() const;
  const class CP_List* CP_List() const;
  const class CPs_Used* CPs_Used() const;
  const class OmitReference* OmitReference() const;
  const class TTCN_CM_TypeDef* TTCN_CM_TypeDef() const;
  const class TS_ConstDclList* TS_ConstDclList() const;
  const class LengthRestriction* LengthRestriction() const;
  const class TS_ParDcls* TS_ParDcls() const;
  const class TestStepGroupId* TestStepGroupId() const;
  const class CP_Dcl* CP_Dcl() const;
  const class TS_VarDclList* TS_VarDclList() const;
  const class RealValue* RealValue() const;
  const class TCompDcls* TCompDcls() const;
  const class DeclarationValue* DeclarationValue() const;
  const class SelectionExpression* SelectionExpression() const;
  const class PredefinedType* PredefinedType() const;
  const class BooleanType* BooleanType() const;
  const class Send* Send() const;
  const class ASN1_CM_TypeDef* ASN1_CM_TypeDef() const;
  const class ConstraintValueAndAttributesOrReplace* ConstraintValueAndAttributesOrReplace() const;
  const class InvalidFieldEncodingIdAndParList* InvalidFieldEncodingIdAndParList() const;
  const class ConstraintValueAndAttributes* ConstraintValueAndAttributes() const;
  const class Qualifier* Qualifier() const;
  const class PDU_IdAndFullId* PDU_IdAndFullId() const;
  const class CP_Dcls* CP_Dcls() const;
  const class SelectExprDef* SelectExprDef() const;
  const class CharacterString* CharacterString() const;
  const class ISO646String* ISO646String() const;
  const class TypeAssignment* TypeAssignment() const;
  const class ParenExpression* ParenExpression() const;
  const class DefaultId* DefaultId() const;
  const class TestStep* TestStep() const;
  const class CreateList* CreateList() const;
  const class ConstraintsPart* ConstraintsPart() const;
  const class ASN1_PDU_TypeDefs* ASN1_PDU_TypeDefs() const;
  const class NumericString* NumericString() const;
  const class BitIdentifier* BitIdentifier() const;
  const class MatchingSymbol* MatchingSymbol() const;
  const class TestGroupRef* TestGroupRef() const;
  const class TimerDclList* TimerDclList() const;
  const class TS_ParDclList* TS_ParDclList() const;
  const class FormalParAndType* FormalParAndType() const;
  const class ReplacementList* ReplacementList() const;
  const class Minus_INFINITY* Minus_INFINITY() const;
  const class GraphicString* GraphicString() const;
  const class ElementTypeList* ElementTypeList() const;
  const class AddExpression* AddExpression() const;
  const class RETURN_* RETURN_() const;
  const class LT* LT() const;
  const class Identifier* Identifier() const;
  const class PresenceConstraint* PresenceConstraint() const;
  const class ComponentReference* ComponentReference() const;
  const class SingleValueLength* SingleValueLength() const;
  const class TestGroupId* TestGroupId() const;
  const class GoTo* GoTo() const;
  const class TS_OpId* TS_OpId() const;
  const class ASuite* ASuite() const;
  const class FAIL* FAIL() const;
  const class Plus_INFINITY* Plus_INFINITY() const;
  const class SimpleExpression* SimpleExpression() const;
  const class ConsValue* ConsValue() const;
  const class TS_ConstDcl* TS_ConstDcl() const;
  const class SO_StandardsRef* SO_StandardsRef() const;
  const class EncVariationCall* EncVariationCall() const;
  const class AFalse* AFalse() const;
  const class PreliminaryFAIL* PreliminaryFAIL() const;
  const class OpCall* OpCall() const;
  const class SuperSet* SuperSet() const;
  const class LowerRangeBound* LowerRangeBound() const;
  const class TimerOp* TimerOp() const;
  const class ElemValue* ElemValue() const;
  const class SourceRef* SourceRef() const;
  const class UpperEndValue* UpperEndValue() const;
  const class SubTypeSpec* SubTypeSpec() const;
  const class Term* Term() const;
  const class PDU_Constraints* PDU_Constraints() const;
  const class PCO_Role* PCO_Role() const;
  const class ElementValueList* ElementValueList() const;
  const class SequenceValue* SequenceValue() const;
  const class SequenceOfType* SequenceOfType() const;
  const class EncodingDefault* EncodingDefault() const;
  const class TestStepGroupOrTestStep* TestStepGroupOrTestStep() const;
  const class WithComponents* WithComponents() const;
  const class BehaviourDescription* BehaviourDescription() const;
  const class CompactTestCase* CompactTestCase() const;
  const class CM_ParValue* CM_ParValue() const;
  const class TTCN_CM_Constraint* TTCN_CM_Constraint() const;
  const class PDU_TypeDefs* PDU_TypeDefs() const;
  const class TCompDcl* TCompDcl() const;
  const class TS_ConstType* TS_ConstType() const;
  const class ElemDcls* ElemDcls() const;
  const class LengthAttribute* LengthAttribute() const;
  const class Permutation* Permutation() const;
  const class DefaultsLibrary* DefaultsLibrary() const;
  const class DerivPath* DerivPath() const;
  const class ImportPart* ImportPart() const;
  const class PASS* PASS() const;
  const class MTC* MTC() const;
  const class SubtypeValueSet* SubtypeValueSet() const;
  const class EnumeratedType* EnumeratedType() const;
  const class DefaultGroupOrDefaultList* DefaultGroupOrDefaultList() const;
  const class Otherwise* Otherwise() const;
  const class LabelId* LabelId() const;
  const class TTCN_CM_Constraints* TTCN_CM_Constraints() const;
  const class ASN1_ASP_TypeDefsByRef* ASN1_ASP_TypeDefsByRef() const;
  const class ASP_ParDcls* ASP_ParDcls() const;
  const class Num_PCOs* Num_PCOs() const;
  const class PreliminaryINCONC* PreliminaryINCONC() const;
  const class PreliminaryPASS* PreliminaryPASS() const;
  const class ABSENT* ABSENT() const;
  const class Done* Done() const;
  const class TC_VarDcls* TC_VarDcls() const;
  const class TS_VarValue* TS_VarValue() const;
  const class TS_ProcDescription* TS_ProcDescription() const;
  const class EncodingDefinitions* EncodingDefinitions() const;
  const class SingleTypeLength* SingleTypeLength() const;
  const class IA5String* IA5String() const;
  const class Ostring* Ostring() const;
  const class RangeValueLength* RangeValueLength() const;
  const class Verdict* Verdict() const;
  const class ASN1_PDU_TypeDefsByRef* ASN1_PDU_TypeDefsByRef() const;
  const class PDU_Id* PDU_Id() const;
  const class ComplexDefinitions* ComplexDefinitions() const;
  const class SelectExprDefList* SelectExprDefList() const;
  const class ASN1_TypeDefinition* ASN1_TypeDefinition() const;
  const class SubSet* SubSet() const;
  const class Complement* Complement() const;
  const class VerdictId* VerdictId() const;
  const class DefaultsRef* DefaultsRef() const;
  const class Bstring* Bstring() const;
  const class TagAttributes* TagAttributes() const;
  const class ActualParList* ActualParList() const;
  const class ValueLength* ValueLength() const;
  const class TestStepGroupOrTestStepList* TestStepGroupOrTestStepList() const;
  const class Cref* Cref() const;
  const class TimerOps* TimerOps() const;
  const class TestCase* TestCase() const;
  const class ASN1_TypeConstraints* ASN1_TypeConstraints() const;
  const class CM_ParDcl* CM_ParDcl() const;
  const class ASN1_Type* ASN1_Type() const;
  const class TimerValue* TimerValue() const;
  const class PDU_FieldValue* PDU_FieldValue() const;
  const class TS_ConstRef* TS_ConstRef() const;
  const class EXTERNAL* EXTERNAL() const;
  const class Indentation* Indentation() const;
  const class TypeConstraints* TypeConstraints() const;
  const class LiteralValue* LiteralValue() const;
  const class StatementLine* StatementLine() const;
  const class SO_TestStepRef* SO_TestStepRef() const;
  const class HEXSTRING* HEXSTRING() const;
  const class NamedTypeAndAttributes* NamedTypeAndAttributes() const;
  const class ConstraintReference* ConstraintReference() const;
  const class ASN1_PDU_Constraints* ASN1_PDU_Constraints() const;
  const class ConsIdAndParList* ConsIdAndParList() const;
  const class SO_Objective* SO_Objective() const;
  const class ParamAndSelection* ParamAndSelection() const;
  const class Receive* Receive() const;
  const class ASN1_CM_Constraints* ASN1_CM_Constraints() const;
  const class PCO_Type* PCO_Type() const;
  const class TComp_Role* TComp_Role() const;
  const class Definitions* Definitions() const;
  const class Seconds* Seconds() const;
  const class ValueConstraint* ValueConstraint() const;
  const class DataObjectReference* DataObjectReference() const;
  const class AliasDef* AliasDef() const;
  const class AIMPLICIT* AIMPLICIT() const;
  const class BitStringValue* BitStringValue() const;
  const class Value* Value() const;
  const class RelOp* RelOp() const;
  const class RelExpression* RelExpression() const;
  const class LineNumber* LineNumber() const;
  const class Number* Number() const;
  const class TypeAndRestriction* TypeAndRestriction() const;
  const class TS_OpIdAndParList* TS_OpIdAndParList() const;
  const class LowerEndpoint* LowerEndpoint() const;
  const class ASN1_Value* ASN1_Value() const;
  const class CancelTimer* CancelTimer() const;
  const class ImportDeclarations* ImportDeclarations() const;
  const class BOOLEAN* BOOLEAN() const;
  const class Replace* Replace() const;
  const class TCompConfigInfo* TCompConfigInfo() const;
  const class SO_CaseIndex* SO_CaseIndex() const;
  const class TS_OpDef* TS_OpDef() const;
  const class ConstraintValue* ConstraintValue() const;
  const class SO_StructureAndObjective* SO_StructureAndObjective() const;
  const class PDU_FieldEncodingCall* PDU_FieldEncodingCall() const;
  const class FullSpecification* FullSpecification() const;
  const class UpperEndpoint* UpperEndpoint() const;
  const class PermittedAlphabet* PermittedAlphabet() const;
  const class BitStringType* BitStringType() const;
  const class TreeReference* TreeReference() const;
  const class MicroSeconds* MicroSeconds() const;
  const class Fail* Fail() const;
  const class StructTypeConstraint* StructTypeConstraint() const;
  const class ASN1_ASP_TypeDefByRef* ASN1_ASP_TypeDefByRef() const;
  const class Restriction* Restriction() const;
  const class EncodingRef* EncodingRef() const;
  const class SO_DefIndex* SO_DefIndex() const;
  const class Construct* Construct() const;
  const class Unit* Unit() const;
  const class TS_ConstDcls* TS_ConstDcls() const;
  const class MilliSeconds* MilliSeconds() const;
  const class CP* CP() const;
  const class TTCN_PDU_TypeDefs* TTCN_PDU_TypeDefs() const;
  const class PCO_TypeDclList* PCO_TypeDclList() const;
  const class EncodingVariationList* EncodingVariationList() const;
  const class INCLUSIVE* INCLUSIVE() const;
  const class SetType* SetType() const;
  const class SO_SelExprId* SO_SelExprId() const;
  const class Bound* Bound() const;
  const class GeneralizedTime* GeneralizedTime() const;
  const class DefaultGroupId* DefaultGroupId() const;
  const class RangeLength* RangeLength() const;
  const class SimpleTypeDefList* SimpleTypeDefList() const;
  const class SO_CaseIndexList* SO_CaseIndexList() const;
};



class AccessSuite
{
  friend class StaticNode;
private:
  static Boolean _core_initialised;
  Boolean    	 _opened_by_me;
  ItexSystem*  	 _system;
  Suite*	 _suite;

  void operator=( const AccessSuite& orig );

public:
  AccessSuite();
  ~AccessSuite();
  AccessSuite* operator->();
  AccessSuite( const AccessSuite& orig );

  Boolean open( const char* suite_name );
  Boolean open( const char* suite_name, const char* asn1_modules_filename );
  Boolean open( Suite* suite );
  Boolean open( ItexSystem* system );
  Boolean open_forced( Suite* suite );
  Boolean close();

  const AccessNode root();
  const AccessNode find( const Identifier& id );
  const AccessNode find( const char* id );

  Boolean trav_root();
  Boolean trav_reference( const Identifier& id );
  Boolean trav_reference( const char* id );
};


#endif