public EnumToBoolMapping(XmlElement element, TypeSpec fcsType)
        {
            enumValue = element.GetAttribute("FCSValue");
            boolMemberName = element.GetAttribute("ForeignMember");
            FCSType = fcsType;

        }

            /// <summary>
            /// Read ctor
            /// </summary>
            internal Type(TypeSpec parent, ResReader reader)
                : base(reader, ChunkTypes.RES_TABLE_TYPE_TYPE)
            {
                this.parent = parent;

                var id = reader.ReadByte();
                reader.Skip(3); // reserved
                if (id != parent.Id)
                {
                    throw new IOException("Type id (" + id + ") " + "doesn't match parent id (" + parent.Id + ").");
                }
                var entryCount = reader.ReadInt32();
                if (entryCount != parent.EntryCount)
                {
                    throw new IOException(string.Format("Type entry count ({0}) doesn't match parent entry count ({1})", entryCount, parent.EntryCount));
                }
                var entriesStart = reader.ReadInt32();
                configuration = new Configuration(reader);
                // Data
                var offsets = reader.ReadIntArray(entryCount);
                var dataSize = (Size - entriesStart);
                if ((dataSize % 4) != 0)
                {
                    throw new IOException("Type data size (" + dataSize + ") is not multiple of 4.");
                }
                for (var i = 0; i < entryCount; i++ )
                {
                    if (offsets[i] != NO_ENTRY)
                    {
                        var actualOffset = reader.Position;
                        var instance = EntryInstance.Read(this, reader);
                        parent.GetEntry(i).Add(instance);
                    } 
                }
            }

 /// <summary>
 /// This .ctor is handy for message inspectors.
 /// Creates a substitute message for the original one with new values.
 /// Binding-specific context is cloned and headers/correlation data are cloned conditionaly
 /// </summary>
 protected RequestMsg(RequestMsg inspectedOriginal,
                   TypeSpec contract, MethodSpec method, bool oneWay, Guid? instance, 
                   bool cloneHeaders = true, bool cloneCorrelation = true) : this(contract, method, oneWay, instance)
 {
   m_ServerTransport = inspectedOriginal.m_ServerTransport;
   CloneState(inspectedOriginal, cloneHeaders, cloneCorrelation);
 }

        private static void InitializeTypes(SymbolTableStack symtabstack)
        {
            // int
            IntegerId = symtabstack.CreateInLocal("integer");
            IntegerType = TypeSpec.CreateType(TypeForm.Scalar);
            IntegerType.Identifier = IntegerId;
            IntegerId.Definition = Definition.TYPE;
            IntegerId.Type = IntegerType;

            // real
            RealId = symtabstack.CreateInLocal("real");
            RealType = TypeSpec.CreateType(TypeForm.Scalar);
            RealType.Identifier = RealId;
            RealId.Definition = Definition.TYPE;
            RealId.Type = RealType;

            // boolean
            BooleanId = symtabstack.CreateInLocal("boolean");
            BooleanType = TypeSpec.CreateType(TypeForm.Enumeration);
            BooleanType.Identifier = BooleanId;
            BooleanId.Definition = Definition.TYPE;
            BooleanId.Type = BooleanType;

            // char
            CharId = symtabstack.CreateInLocal("char");
            CharType = TypeSpec.CreateType(TypeForm.Scalar);
            CharType.Identifier = CharId;
            CharId.Definition = Definition.TYPE;
            CharId.Type = CharType;

            //
            UndefinedType = TypeSpec.CreateType(TypeForm.Scalar);
        }

 /// <summary>
 /// This .ctor is handy for message inspectors.
 /// Creates a substitute message for the original one with new values.
 /// Binding-specific context is cloned and headers/correlation data are cloned conditionaly
 /// </summary>
 public RequestAnyMsg(RequestMsg inspectedOriginal,
     TypeSpec contract, MethodSpec method, bool oneWay, Guid? instance, object[] args,
     bool cloneHeaders = true, bool cloneCorrelation = true)
     : base(inspectedOriginal, contract, method, oneWay, instance, cloneHeaders, cloneCorrelation)
 {
     m_Arguments = args;
 }

        protected BaseClassMapping(XmlElement node)
        {
            FCSType = new TypeSpec(node.GetAttribute("FCSType"), TypeSpec.TypeSpecCategories.FCSType);
            ForeignType = new TypeSpec(node.GetAttribute("ForeignType"), TypeSpec.TypeSpecCategories.ForeignType);

            ForeignType.HeaderFile = XmlUtils.GetOptionalAttribute(node, "HeaderFile");
        }

 protected virtual object CreateNestedDelta(object propValue, TypeSpec propValueType, Type propertyType)
 {
     if (propValueType.SerializationMode == TypeSerializationMode.Structured)
         return new ObjectDelta(propValue, propValueType, TypeMapper, this);
     if (propValueType.IsCollection)
         return new CollectionDelta(propValue, propValueType, TypeMapper, this);
     throw new NotImplementedException();
 }

 //static .ctor
 static AuthServiceClient()
 {
     var t = typeof(IAuthService);
     s_ts_CONTRACT = new TypeSpec(t);
     s_ms_CloseSession = new MethodSpec(t.GetMethod("CloseSession", new Type[] { typeof(Guid) }));
     s_ms_CreateSession = new MethodSpec(t.GetMethod("CreateSession", new Type[] { typeof(long) }));
     s_ms_GetSessionUser = new MethodSpec(t.GetMethod("GetSessionUser", new Type[] { typeof(Guid) }));
 }

        public PomonaJsonSerializerTypeEntry(TypeSpec type)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type));
            this.type = type;

            BuildAcceleratedPropertyWritingAction();
        }

 //static .ctor
 static TestContractAClient()
 {
     var t = typeof(NFX.NUnit.Glue.ITestContractA);
      s_ts_CONTRACT = new TypeSpec(t);
      @s_ms_Method1_0 = new MethodSpec(t.GetMethod("Method1", new Type[]{ typeof(@[email protected]) }));
      @s_ms_Method2_1 = new MethodSpec(t.GetMethod("Method2", new Type[]{ typeof(@[email protected]) }));
      @s_ms_Sleeper_2 = new MethodSpec(t.GetMethod("Sleeper", new Type[]{ typeof(@[email protected]) }));
 }

 protected Delta(object original, TypeSpec type, ITypeMapper typeMapper, Delta parent = null)
 {
     if (original == null) throw new ArgumentNullException("original");
     if (type == null) throw new ArgumentNullException("type");
     if (typeMapper == null) throw new ArgumentNullException("typeMapper");
     Original = original;
     Type = type;
     TypeMapper = typeMapper;
     this.parent = parent;
 }

 public static void Error_InvalidConstantType(TypeSpec t, Location loc, Report Report)
 {
     if (t.IsGenericParameter) {
         Report.Error (1959, loc,
             "Type parameter `{0}' cannot be declared const", TypeManager.CSharpName (t));
     } else {
         Report.Error (283, loc,
             "The type `{0}' cannot be declared const", TypeManager.CSharpName (t));
     }
 }

 public ItemValueDeserializerNode(TypeSpec expectedBaseType,
                                  IDeserializationContext context,
                                  string expandPath = "",
                                  IDeserializerNode parent = null)
 {
     Parent = parent;
     ExpectedBaseType = expectedBaseType;
     Context = context;
     ExpandPath = expandPath;
     this.valueType = expectedBaseType;
 }

        public MemberSpec(string specText, TypeSpec.TypeSpecCategories typeCategory)
        {
            int index = specText.LastIndexOf(' ');
            string[] bits = new string[2];
            bits[0] = specText.Substring(0, index);
            bits[1] = specText.Substring(index + 1);

            Type = new TypeSpec(bits[0], typeCategory);
            Name = bits[1];

        }

 //static .ctor
 static JokeContractClient()
 {
     var t = typeof(@[email protected]);
      s_ts_CONTRACT = new TypeSpec(t);
      @s_ms_Echo_0 = new MethodSpec(t.GetMethod("Echo", new Type[]{ typeof(@[email protected]) }));
      @s_ms_UnsecureEcho_1 = new MethodSpec(t.GetMethod("UnsecureEcho", new Type[]{ typeof(@[email protected]) }));
      @s_ms_UnsecEchoMar_2 = new MethodSpec(t.GetMethod("UnsecEchoMar", new Type[]{ typeof(@[email protected]) }));
      @s_ms_SimpleWorkAny_3 = new MethodSpec(t.GetMethod("SimpleWorkAny", new Type[]{ typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]) }));
      @s_ms_SimpleWorkMar_4 = new MethodSpec(t.GetMethod("SimpleWorkMar", new Type[]{ typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]) }));
      @s_ms_DBWork_5 = new MethodSpec(t.GetMethod("DBWork", new Type[]{ typeof(@[email protected]), typeof(@[email protected]), typeof(@[email protected]) }));
      @s_ms_Notify_6 = new MethodSpec(t.GetMethod("Notify", new Type[]{ typeof(@[email protected]) }));
      @s_ms_ObjectWork_7 = new MethodSpec(t.GetMethod("ObjectWork", new Type[]{ typeof(@[email protected]) }));
 }

 public RouteAction Match(HttpMethod method, PathNodeType nodeType, TypeSpec resourceType)
 {
     switch (nodeType)
     {
         case PathNodeType.Collection:
             return MatchCollectionNodeRequest(method, (ResourceType)resourceType);
         case PathNodeType.Resource:
             if (!MethodInfo.Name.StartsWith(method.ToString()))
                 return null;
             return MatchResourceNodeRequest(method, (ResourceType)resourceType);
     }
     return null;
 }

 protected Delta(object original, TypeSpec type, ITypeResolver typeMapper, Delta parent = null)
 {
     if (original == null)
         throw new ArgumentNullException(nameof(original));
     if (type == null)
         throw new ArgumentNullException(nameof(type));
     if (typeMapper == null)
         throw new ArgumentNullException(nameof(typeMapper));
     Original = original;
     Type = type;
     TypeMapper = typeMapper;
     Parent = parent;
 }

		/// <summary>
		/// Resolve an IField from its name and a declaring TypeSpec.
		/// </summary>
		/// <param name="declaringType">Declaring TypeSpec</param>
		/// <param name="fieldName">Field name</param>
		/// <returns>IField, or null if none found</returns>
		public IField ResolveField(TypeSpec declaringType, String fieldName)
		{
			TypeDef typeDef = declaringType.ResolveTypeDef();
			if (typeDef == null)
				return null;

			FieldDef fieldDef = typeDef.FindField(fieldName);
			if (fieldDef == null)
				return null;

			MemberRef memberRef = new MemberRefUser(_module, fieldDef.Name, fieldDef.FieldSig, declaringType);
			return this.Importer.Import(memberRef);
		}

        //
        private TypeSpec(string value)
        {
            form = TypeForm.Array;

            TypeSpec indexType = new TypeSpec(TypeForm.Subrange);
            // FIXME: Predefined
            // indexType.SetAttribute(TypeKey.SubrangeBaseType, Predefined.IntegerType);
            indexType.SetAttribute(TypeKey.SubrangeMinValue, 1);
            indexType.SetAttribute(TypeKey.SubrangeMaxValue, value.Length);
            SetAttribute(TypeKey.ArrayIndexType, indexType);
            // FIXME: Predefined
            // SetAttribute(TypeKey.ArrayElementType, Predefined.CharType);
            SetAttribute(TypeKey.ArrayElementCount, value.Length);
        }

        private static bool TryGetJsonWriterMethodForWritingType(TypeSpec type, out MethodInfo method)
        {
            method = null;
            if (type.SerializationMode != TypeSerializationMode.Value)
                return false;

            method = typeof(JsonWriter)
                .GetMethods(BindingFlags.Instance | BindingFlags.Public)
                .Where(x => x.Name == "WriteValue")
                .FirstOrDefault(
                    x => x.GetParameters().Length == 1 && x.GetParameters()[0].ParameterType == type.Type);

            return method != null;
        }