// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. [assembly:System.Reflection.AssemblyVersionAttribute("0.11.1.0")] [assembly:System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly:System.Reflection.AssemblyCopyrightAttribute("Copyright © 2008 - 2018 Jb Evain")] [assembly:System.Reflection.AssemblyFileVersionAttribute("0.11.1.0")] [assembly:System.Reflection.AssemblyInformationalVersionAttribute("0.11.1.0")] [assembly:System.Reflection.AssemblyProductAttribute("Mono.Cecil")] [assembly:System.Reflection.AssemblyTitleAttribute("Mono.Cecil")] [assembly:System.Runtime.CompilerServices.CompilationRelaxationsAttribute(8)] [assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Mdb, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")] [assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Pdb, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")] [assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Rocks, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")] [assembly:System.Runtime.CompilerServices.InternalsVisibleToAttribute("Mono.Cecil.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df")] [assembly:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows=true)] [assembly:System.Runtime.InteropServices.ComVisibleAttribute(false)] [assembly:System.Runtime.InteropServices.GuidAttribute("fd225bb4-fa53-44b2-a6db-85f5e48dcb54")] [assembly:System.Security.Permissions.SecurityPermissionAttribute(System.Security.Permissions.SecurityAction.RequestMinimum, SkipVerification=true)] namespace Mono.Cecil { [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct ArrayDimension { private int _dummyPrimitive; public ArrayDimension(System.Nullable lowerBound, System.Nullable upperBound) { throw null; } public bool IsSized { get { throw null; } } public System.Nullable LowerBound { get { throw null; } set { } } public System.Nullable UpperBound { get { throw null; } set { } } public override string ToString() { throw null; } } public sealed partial class ArrayMarshalInfo : Mono.Cecil.MarshalInfo { public ArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { } public Mono.Cecil.NativeType ElementType { get { throw null; } set { } } public int Size { get { throw null; } set { } } public int SizeParameterIndex { get { throw null; } set { } } public int SizeParameterMultiplier { get { throw null; } set { } } } public sealed partial class ArrayType : Mono.Cecil.TypeSpecification { public ArrayType(Mono.Cecil.TypeReference type) { } public ArrayType(Mono.Cecil.TypeReference type, int rank) { } public Mono.Collections.Generic.Collection Dimensions { get { throw null; } } public override string FullName { get { throw null; } } public override bool IsArray { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } public bool IsVector { get { throw null; } } public override string Name { get { throw null; } } public int Rank { get { throw null; } } } [System.FlagsAttribute] public enum AssemblyAttributes : uint { DisableJITCompileOptimizer = (uint)16384, EnableJITCompileTracking = (uint)32768, PublicKey = (uint)1, Retargetable = (uint)256, SideBySideCompatible = (uint)0, WindowsRuntime = (uint)512, } public sealed partial class AssemblyDefinition : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider, System.IDisposable { internal AssemblyDefinition() { } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public Mono.Cecil.MethodDefinition EntryPoint { get { throw null; } set { } } public string FullName { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public bool HasSecurityDeclarations { get { throw null; } } public Mono.Cecil.ModuleDefinition MainModule { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public Mono.Collections.Generic.Collection Modules { get { throw null; } } public Mono.Cecil.AssemblyNameDefinition Name { get { throw null; } set { } } public Mono.Collections.Generic.Collection SecurityDeclarations { get { throw null; } } public static Mono.Cecil.AssemblyDefinition CreateAssembly(Mono.Cecil.AssemblyNameDefinition assemblyName, string moduleName, Mono.Cecil.ModuleKind kind) { throw null; } public static Mono.Cecil.AssemblyDefinition CreateAssembly(Mono.Cecil.AssemblyNameDefinition assemblyName, string moduleName, Mono.Cecil.ModuleParameters parameters) { throw null; } public void Dispose() { } public static Mono.Cecil.AssemblyDefinition ReadAssembly(System.IO.Stream stream) { throw null; } public static Mono.Cecil.AssemblyDefinition ReadAssembly(System.IO.Stream stream, Mono.Cecil.ReaderParameters parameters) { throw null; } public static Mono.Cecil.AssemblyDefinition ReadAssembly(string fileName) { throw null; } public static Mono.Cecil.AssemblyDefinition ReadAssembly(string fileName, Mono.Cecil.ReaderParameters parameters) { throw null; } public override string ToString() { throw null; } public void Write() { } public void Write(Mono.Cecil.WriterParameters parameters) { } public void Write(System.IO.Stream stream) { } public void Write(System.IO.Stream stream, Mono.Cecil.WriterParameters parameters) { } public void Write(string fileName) { } public void Write(string fileName, Mono.Cecil.WriterParameters parameters) { } } public enum AssemblyHashAlgorithm : uint { None = (uint)0, Reserved = (uint)32771, SHA1 = (uint)32772, } public sealed partial class AssemblyLinkedResource : Mono.Cecil.Resource { public AssemblyLinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags) { } public AssemblyLinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags, Mono.Cecil.AssemblyNameReference reference) { } public Mono.Cecil.AssemblyNameReference Assembly { get { throw null; } set { } } public override Mono.Cecil.ResourceType ResourceType { get { throw null; } } } public sealed partial class AssemblyNameDefinition : Mono.Cecil.AssemblyNameReference { public AssemblyNameDefinition(string name, System.Version version) : base (default(string), default(System.Version)) { } public override byte[] Hash { get { throw null; } } } public partial class AssemblyNameReference : Mono.Cecil.IMetadataScope, Mono.Cecil.IMetadataTokenProvider { public AssemblyNameReference(string name, System.Version version) { } public Mono.Cecil.AssemblyAttributes Attributes { get { throw null; } set { } } public string Culture { get { throw null; } set { } } public string FullName { get { throw null; } } public virtual byte[] Hash { get { throw null; } set { } } public Mono.Cecil.AssemblyHashAlgorithm HashAlgorithm { get { throw null; } set { } } public bool HasPublicKey { get { throw null; } set { } } public bool IsRetargetable { get { throw null; } set { } } public bool IsSideBySideCompatible { get { throw null; } set { } } public bool IsWindowsRuntime { get { throw null; } set { } } public virtual Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public string Name { get { throw null; } set { } } public byte[] PublicKey { get { throw null; } set { } } public byte[] PublicKeyToken { get { throw null; } set { } } public System.Version Version { get { throw null; } set { } } public static Mono.Cecil.AssemblyNameReference Parse(string fullName) { throw null; } public override string ToString() { throw null; } } [System.SerializableAttribute] public sealed partial class AssemblyResolutionException : System.IO.FileNotFoundException { public AssemblyResolutionException(Mono.Cecil.AssemblyNameReference reference) { } public AssemblyResolutionException(Mono.Cecil.AssemblyNameReference reference, System.Exception innerException) { } public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } } } public sealed partial class AssemblyResolveEventArgs : System.EventArgs { public AssemblyResolveEventArgs(Mono.Cecil.AssemblyNameReference reference) { } public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } } } public delegate Mono.Cecil.AssemblyDefinition AssemblyResolveEventHandler(object sender, Mono.Cecil.AssemblyNameReference reference); public abstract partial class BaseAssemblyResolver : Mono.Cecil.IAssemblyResolver, System.IDisposable { protected BaseAssemblyResolver() { } public event Mono.Cecil.AssemblyResolveEventHandler ResolveFailure { add { } remove { } } public void AddSearchDirectory(string directory) { } public void Dispose() { } protected virtual void Dispose(bool disposing) { } public string[] GetSearchDirectories() { throw null; } public void RemoveSearchDirectory(string directory) { } public virtual Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name) { throw null; } public virtual Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name, Mono.Cecil.ReaderParameters parameters) { throw null; } protected virtual Mono.Cecil.AssemblyDefinition SearchDirectory(Mono.Cecil.AssemblyNameReference name, System.Collections.Generic.IEnumerable directories, Mono.Cecil.ReaderParameters parameters) { throw null; } } public sealed partial class ByReferenceType : Mono.Cecil.TypeSpecification { public ByReferenceType(Mono.Cecil.TypeReference type) { } public override string FullName { get { throw null; } } public override bool IsByReference { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } public override string Name { get { throw null; } } } public sealed partial class CallSite : Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature { public CallSite(Mono.Cecil.TypeReference returnType) { } public Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } } public bool ExplicitThis { get { throw null; } set { } } public string FullName { get { throw null; } } public bool HasParameters { get { throw null; } } public bool HasThis { get { throw null; } set { } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } } public Mono.Cecil.ModuleDefinition Module { get { throw null; } } public string Name { get { throw null; } set { } } public string Namespace { get { throw null; } set { } } public Mono.Collections.Generic.Collection Parameters { get { throw null; } } public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } } public Mono.Cecil.IMetadataScope Scope { get { throw null; } } public override string ToString() { throw null; } } [System.Diagnostics.DebuggerDisplayAttribute("{AttributeType}")] public sealed partial class CustomAttribute : Mono.Cecil.ICustomAttribute { public CustomAttribute(Mono.Cecil.MethodReference constructor) { } public CustomAttribute(Mono.Cecil.MethodReference constructor, byte[] blob) { } public Mono.Cecil.TypeReference AttributeType { get { throw null; } } public Mono.Cecil.MethodReference Constructor { get { throw null; } set { } } public Mono.Collections.Generic.Collection ConstructorArguments { get { throw null; } } public Mono.Collections.Generic.Collection Fields { get { throw null; } } public bool HasConstructorArguments { get { throw null; } } public bool HasFields { get { throw null; } } public bool HasProperties { get { throw null; } } public bool IsResolved { get { throw null; } } public Mono.Collections.Generic.Collection Properties { get { throw null; } } public byte[] GetBlob() { throw null; } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct CustomAttributeArgument { private object _dummy; public CustomAttributeArgument(Mono.Cecil.TypeReference type, object value) { throw null; } public Mono.Cecil.TypeReference Type { get { throw null; } } public object Value { get { throw null; } } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct CustomAttributeNamedArgument { private object _dummy; public CustomAttributeNamedArgument(string name, Mono.Cecil.CustomAttributeArgument argument) { throw null; } public Mono.Cecil.CustomAttributeArgument Argument { get { throw null; } } public string Name { get { throw null; } } } public sealed partial class CustomMarshalInfo : Mono.Cecil.MarshalInfo { public CustomMarshalInfo() : base (default(Mono.Cecil.NativeType)) { } public string Cookie { get { throw null; } set { } } public System.Guid Guid { get { throw null; } set { } } public Mono.Cecil.TypeReference ManagedType { get { throw null; } set { } } public string UnmanagedType { get { throw null; } set { } } } public partial class DefaultAssemblyResolver : Mono.Cecil.BaseAssemblyResolver { public DefaultAssemblyResolver() { } protected override void Dispose(bool disposing) { } protected void RegisterAssembly(Mono.Cecil.AssemblyDefinition assembly) { } public override Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name) { throw null; } } public partial class DefaultMetadataImporter : Mono.Cecil.IMetadataImporter { protected readonly Mono.Cecil.ModuleDefinition module; public DefaultMetadataImporter(Mono.Cecil.ModuleDefinition module) { } public virtual Mono.Cecil.AssemblyNameReference ImportReference(Mono.Cecil.AssemblyNameReference name) { throw null; } public virtual Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; } public virtual Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; } public virtual Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; } protected Mono.Cecil.IMetadataScope ImportScope(Mono.Cecil.IMetadataScope scope) { throw null; } protected virtual Mono.Cecil.IMetadataScope ImportScope(Mono.Cecil.TypeReference type) { throw null; } } public partial class DefaultReflectionImporter : Mono.Cecil.IReflectionImporter { protected readonly Mono.Cecil.ModuleDefinition module; public DefaultReflectionImporter(Mono.Cecil.ModuleDefinition module) { } public virtual Mono.Cecil.AssemblyNameReference ImportReference(System.Reflection.AssemblyName name) { throw null; } public virtual Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; } public virtual Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; } public virtual Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; } protected Mono.Cecil.AssemblyNameReference ImportScope(System.Reflection.Assembly assembly) { throw null; } protected virtual Mono.Cecil.IMetadataScope ImportScope(System.Type type) { throw null; } } public sealed partial class EmbeddedResource : Mono.Cecil.Resource { public EmbeddedResource(string name, Mono.Cecil.ManifestResourceAttributes attributes, byte[] data) { } public EmbeddedResource(string name, Mono.Cecil.ManifestResourceAttributes attributes, System.IO.Stream stream) { } public override Mono.Cecil.ResourceType ResourceType { get { throw null; } } public byte[] GetResourceData() { throw null; } public System.IO.Stream GetResourceStream() { throw null; } } [System.FlagsAttribute] public enum EventAttributes : ushort { None = (ushort)0, RTSpecialName = (ushort)1024, SpecialName = (ushort)512, } public sealed partial class EventDefinition : Mono.Cecil.EventReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider { public EventDefinition(string name, Mono.Cecil.EventAttributes attributes, Mono.Cecil.TypeReference eventType) : base (default(string), default(Mono.Cecil.TypeReference)) { } public Mono.Cecil.MethodDefinition AddMethod { get { throw null; } set { } } public Mono.Cecil.EventAttributes Attributes { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } } public bool HasCustomAttributes { get { throw null; } } public bool HasOtherMethods { get { throw null; } } public Mono.Cecil.MethodDefinition InvokeMethod { get { throw null; } set { } } public override bool IsDefinition { get { throw null; } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public Mono.Collections.Generic.Collection OtherMethods { get { throw null; } } public Mono.Cecil.MethodDefinition RemoveMethod { get { throw null; } set { } } public override Mono.Cecil.EventDefinition Resolve() { throw null; } } public abstract partial class EventReference : Mono.Cecil.MemberReference { protected EventReference(string name, Mono.Cecil.TypeReference eventType) { } public Mono.Cecil.TypeReference EventType { get { throw null; } set { } } public override string FullName { get { throw null; } } public abstract new Mono.Cecil.EventDefinition Resolve(); protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; } } public sealed partial class ExportedType : Mono.Cecil.IMetadataTokenProvider { public ExportedType(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope) { } public Mono.Cecil.TypeAttributes Attributes { get { throw null; } set { } } public Mono.Cecil.ExportedType DeclaringType { get { throw null; } set { } } public string FullName { get { throw null; } } public bool HasSecurity { get { throw null; } set { } } public int Identifier { get { throw null; } set { } } public bool IsAbstract { get { throw null; } set { } } public bool IsAnsiClass { get { throw null; } set { } } public bool IsAutoClass { get { throw null; } set { } } public bool IsAutoLayout { get { throw null; } set { } } public bool IsBeforeFieldInit { get { throw null; } set { } } public bool IsClass { get { throw null; } set { } } public bool IsExplicitLayout { get { throw null; } set { } } public bool IsForwarder { get { throw null; } set { } } public bool IsImport { get { throw null; } set { } } public bool IsInterface { get { throw null; } set { } } public bool IsNestedAssembly { get { throw null; } set { } } public bool IsNestedFamily { get { throw null; } set { } } public bool IsNestedFamilyAndAssembly { get { throw null; } set { } } public bool IsNestedFamilyOrAssembly { get { throw null; } set { } } public bool IsNestedPrivate { get { throw null; } set { } } public bool IsNestedPublic { get { throw null; } set { } } public bool IsNotPublic { get { throw null; } set { } } public bool IsPublic { get { throw null; } set { } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSealed { get { throw null; } set { } } public bool IsSequentialLayout { get { throw null; } set { } } public bool IsSerializable { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public bool IsUnicodeClass { get { throw null; } set { } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public string Name { get { throw null; } set { } } public string Namespace { get { throw null; } set { } } public Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } } public Mono.Cecil.TypeDefinition Resolve() { throw null; } public override string ToString() { throw null; } } [System.FlagsAttribute] public enum FieldAttributes : ushort { Assembly = (ushort)3, CompilerControlled = (ushort)0, FamANDAssem = (ushort)2, Family = (ushort)4, FamORAssem = (ushort)5, FieldAccessMask = (ushort)7, HasDefault = (ushort)32768, HasFieldMarshal = (ushort)4096, HasFieldRVA = (ushort)256, InitOnly = (ushort)32, Literal = (ushort)64, NotSerialized = (ushort)128, PInvokeImpl = (ushort)8192, Private = (ushort)1, Public = (ushort)6, RTSpecialName = (ushort)1024, SpecialName = (ushort)512, Static = (ushort)16, } public sealed partial class FieldDefinition : Mono.Cecil.FieldReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider { public FieldDefinition(string name, Mono.Cecil.FieldAttributes attributes, Mono.Cecil.TypeReference fieldType) : base (default(string), default(Mono.Cecil.TypeReference)) { } public Mono.Cecil.FieldAttributes Attributes { get { throw null; } set { } } public object Constant { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } } public bool HasConstant { get { throw null; } set { } } public bool HasCustomAttributes { get { throw null; } } public bool HasDefault { get { throw null; } set { } } public bool HasLayoutInfo { get { throw null; } } public bool HasMarshalInfo { get { throw null; } } public byte[] InitialValue { get { throw null; } set { } } public bool IsAssembly { get { throw null; } set { } } public bool IsCompilerControlled { get { throw null; } set { } } public override bool IsDefinition { get { throw null; } } public bool IsFamily { get { throw null; } set { } } public bool IsFamilyAndAssembly { get { throw null; } set { } } public bool IsFamilyOrAssembly { get { throw null; } set { } } public bool IsInitOnly { get { throw null; } set { } } public bool IsLiteral { get { throw null; } set { } } public bool IsNotSerialized { get { throw null; } set { } } public bool IsPInvokeImpl { get { throw null; } set { } } public bool IsPrivate { get { throw null; } set { } } public bool IsPublic { get { throw null; } set { } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public bool IsStatic { get { throw null; } set { } } public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } } public int Offset { get { throw null; } set { } } public int RVA { get { throw null; } } public override Mono.Cecil.FieldDefinition Resolve() { throw null; } } public partial class FieldReference : Mono.Cecil.MemberReference { public FieldReference(string name, Mono.Cecil.TypeReference fieldType) { } public FieldReference(string name, Mono.Cecil.TypeReference fieldType, Mono.Cecil.TypeReference declaringType) { } public override bool ContainsGenericParameter { get { throw null; } } public Mono.Cecil.TypeReference FieldType { get { throw null; } set { } } public override string FullName { get { throw null; } } public virtual new Mono.Cecil.FieldDefinition Resolve() { throw null; } protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; } } public sealed partial class FixedArrayMarshalInfo : Mono.Cecil.MarshalInfo { public FixedArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { } public Mono.Cecil.NativeType ElementType { get { throw null; } set { } } public int Size { get { throw null; } set { } } } public sealed partial class FixedSysStringMarshalInfo : Mono.Cecil.MarshalInfo { public FixedSysStringMarshalInfo() : base (default(Mono.Cecil.NativeType)) { } public int Size { get { throw null; } set { } } } public sealed partial class FunctionPointerType : Mono.Cecil.TypeSpecification, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature { public FunctionPointerType() { } public Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } } public override bool ContainsGenericParameter { get { throw null; } } public bool ExplicitThis { get { throw null; } set { } } public override string FullName { get { throw null; } } public bool HasParameters { get { throw null; } } public bool HasThis { get { throw null; } set { } } public override bool IsFunctionPointer { get { throw null; } } public Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } } public override Mono.Cecil.ModuleDefinition Module { get { throw null; } } public override string Name { get { throw null; } set { } } public override string Namespace { get { throw null; } set { } } public Mono.Collections.Generic.Collection Parameters { get { throw null; } } public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } } public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } } public override Mono.Cecil.TypeReference GetElementType() { throw null; } public override Mono.Cecil.TypeDefinition Resolve() { throw null; } } public sealed partial class GenericInstanceMethod : Mono.Cecil.MethodSpecification, Mono.Cecil.IGenericInstance, Mono.Cecil.IMetadataTokenProvider { public GenericInstanceMethod(Mono.Cecil.MethodReference method) { } public override bool ContainsGenericParameter { get { throw null; } } public override string FullName { get { throw null; } } public Mono.Collections.Generic.Collection GenericArguments { get { throw null; } } public bool HasGenericArguments { get { throw null; } } public override bool IsGenericInstance { get { throw null; } } } public sealed partial class GenericInstanceType : Mono.Cecil.TypeSpecification, Mono.Cecil.IGenericInstance, Mono.Cecil.IMetadataTokenProvider { public GenericInstanceType(Mono.Cecil.TypeReference type) { } public override bool ContainsGenericParameter { get { throw null; } } public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } } public override string FullName { get { throw null; } } public Mono.Collections.Generic.Collection GenericArguments { get { throw null; } } public bool HasGenericArguments { get { throw null; } } public override bool IsGenericInstance { get { throw null; } } } public sealed partial class GenericParameter : Mono.Cecil.TypeReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider { public GenericParameter(Mono.Cecil.IGenericParameterProvider owner) : base (default(string), default(string)) { } public GenericParameter(string name, Mono.Cecil.IGenericParameterProvider owner) : base (default(string), default(string)) { } public Mono.Cecil.GenericParameterAttributes Attributes { get { throw null; } set { } } public Mono.Collections.Generic.Collection Constraints { get { throw null; } } public override bool ContainsGenericParameter { get { throw null; } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public Mono.Cecil.MethodReference DeclaringMethod { get { throw null; } } public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } } public override string FullName { get { throw null; } } public bool HasConstraints { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public bool HasDefaultConstructorConstraint { get { throw null; } set { } } public bool HasNotNullableValueTypeConstraint { get { throw null; } set { } } public bool HasReferenceTypeConstraint { get { throw null; } set { } } public bool IsContravariant { get { throw null; } set { } } public bool IsCovariant { get { throw null; } set { } } public override bool IsGenericParameter { get { throw null; } } public bool IsNonVariant { get { throw null; } set { } } public override Mono.Cecil.MetadataType MetadataType { get { throw null; } } public override Mono.Cecil.ModuleDefinition Module { get { throw null; } } public override string Name { get { throw null; } } public override string Namespace { get { throw null; } set { } } public Mono.Cecil.IGenericParameterProvider Owner { get { throw null; } } public int Position { get { throw null; } } public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } } public Mono.Cecil.GenericParameterType Type { get { throw null; } } public override Mono.Cecil.TypeDefinition Resolve() { throw null; } } [System.FlagsAttribute] public enum GenericParameterAttributes : ushort { Contravariant = (ushort)2, Covariant = (ushort)1, DefaultConstructorConstraint = (ushort)16, NonVariant = (ushort)0, NotNullableValueTypeConstraint = (ushort)8, ReferenceTypeConstraint = (ushort)4, SpecialConstraintMask = (ushort)28, VarianceMask = (ushort)3, } public sealed partial class GenericParameterConstraint : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider { public GenericParameterConstraint(Mono.Cecil.TypeReference constraintType) { } public Mono.Cecil.TypeReference ConstraintType { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } } public enum GenericParameterType { Method = 1, Type = 0, } public partial interface IAssemblyResolver : System.IDisposable { Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name); Mono.Cecil.AssemblyDefinition Resolve(Mono.Cecil.AssemblyNameReference name, Mono.Cecil.ReaderParameters parameters); } public partial interface IConstantProvider : Mono.Cecil.IMetadataTokenProvider { object Constant { get; set; } bool HasConstant { get; set; } } public partial interface ICustomAttribute { Mono.Cecil.TypeReference AttributeType { get; } Mono.Collections.Generic.Collection ConstructorArguments { get; } Mono.Collections.Generic.Collection Fields { get; } bool HasConstructorArguments { get; } bool HasFields { get; } bool HasProperties { get; } Mono.Collections.Generic.Collection Properties { get; } } public partial interface ICustomAttributeProvider : Mono.Cecil.IMetadataTokenProvider { Mono.Collections.Generic.Collection CustomAttributes { get; } bool HasCustomAttributes { get; } } public partial interface IGenericInstance : Mono.Cecil.IMetadataTokenProvider { Mono.Collections.Generic.Collection GenericArguments { get; } bool HasGenericArguments { get; } } public partial interface IGenericParameterProvider : Mono.Cecil.IMetadataTokenProvider { Mono.Collections.Generic.Collection GenericParameters { get; } Mono.Cecil.GenericParameterType GenericParameterType { get; } bool HasGenericParameters { get; } bool IsDefinition { get; } Mono.Cecil.ModuleDefinition Module { get; } } public partial interface IMarshalInfoProvider : Mono.Cecil.IMetadataTokenProvider { bool HasMarshalInfo { get; } Mono.Cecil.MarshalInfo MarshalInfo { get; set; } } public partial interface IMemberDefinition : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider { Mono.Cecil.TypeDefinition DeclaringType { get; set; } string FullName { get; } bool IsRuntimeSpecialName { get; set; } bool IsSpecialName { get; set; } string Name { get; set; } } public partial interface IMetadataImporter { Mono.Cecil.AssemblyNameReference ImportReference(Mono.Cecil.AssemblyNameReference reference); Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context); Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context); Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context); } public partial interface IMetadataImporterProvider { Mono.Cecil.IMetadataImporter GetMetadataImporter(Mono.Cecil.ModuleDefinition module); } public partial interface IMetadataResolver { Mono.Cecil.FieldDefinition Resolve(Mono.Cecil.FieldReference field); Mono.Cecil.MethodDefinition Resolve(Mono.Cecil.MethodReference method); Mono.Cecil.TypeDefinition Resolve(Mono.Cecil.TypeReference type); } public partial interface IMetadataScope : Mono.Cecil.IMetadataTokenProvider { Mono.Cecil.MetadataScopeType MetadataScopeType { get; } string Name { get; set; } } public partial interface IMetadataTokenProvider { Mono.Cecil.MetadataToken MetadataToken { get; set; } } public partial interface IMethodSignature : Mono.Cecil.IMetadataTokenProvider { Mono.Cecil.MethodCallingConvention CallingConvention { get; set; } bool ExplicitThis { get; set; } bool HasParameters { get; } bool HasThis { get; set; } Mono.Cecil.MethodReturnType MethodReturnType { get; } Mono.Collections.Generic.Collection Parameters { get; } Mono.Cecil.TypeReference ReturnType { get; set; } } public partial interface IModifierType { Mono.Cecil.TypeReference ElementType { get; } Mono.Cecil.TypeReference ModifierType { get; } } public sealed partial class InterfaceImplementation : Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider { public InterfaceImplementation(Mono.Cecil.TypeReference interfaceType) { } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public Mono.Cecil.TypeReference InterfaceType { get { throw null; } set { } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } } public partial interface IReflectionImporter { Mono.Cecil.AssemblyNameReference ImportReference(System.Reflection.AssemblyName reference); Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context); Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context); Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context); } public partial interface IReflectionImporterProvider { Mono.Cecil.IReflectionImporter GetReflectionImporter(Mono.Cecil.ModuleDefinition module); } public partial interface ISecurityDeclarationProvider : Mono.Cecil.IMetadataTokenProvider { bool HasSecurityDeclarations { get; } Mono.Collections.Generic.Collection SecurityDeclarations { get; } } public sealed partial class LinkedResource : Mono.Cecil.Resource { public LinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags) { } public LinkedResource(string name, Mono.Cecil.ManifestResourceAttributes flags, string file) { } public string File { get { throw null; } set { } } public byte[] Hash { get { throw null; } } public override Mono.Cecil.ResourceType ResourceType { get { throw null; } } } [System.FlagsAttribute] public enum ManifestResourceAttributes : uint { Private = (uint)2, Public = (uint)1, VisibilityMask = (uint)7, } public partial class MarshalInfo { public MarshalInfo(Mono.Cecil.NativeType native) { } public Mono.Cecil.NativeType NativeType { get { throw null; } set { } } } public abstract partial class MemberReference : Mono.Cecil.IMetadataTokenProvider { internal MemberReference() { } public virtual bool ContainsGenericParameter { get { throw null; } } public virtual Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } } public abstract string FullName { get; } public virtual bool IsDefinition { get { throw null; } } public bool IsWindowsRuntimeProjection { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public virtual Mono.Cecil.ModuleDefinition Module { get { throw null; } } public virtual string Name { get { throw null; } set { } } public Mono.Cecil.IMemberDefinition Resolve() { throw null; } protected abstract Mono.Cecil.IMemberDefinition ResolveDefinition(); public override string ToString() { throw null; } } public enum MetadataKind { Ecma335 = 0, ManagedWindowsMetadata = 2, WindowsMetadata = 1, } public partial class MetadataResolver : Mono.Cecil.IMetadataResolver { public MetadataResolver(Mono.Cecil.IAssemblyResolver assemblyResolver) { } public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } } public static Mono.Cecil.MethodDefinition GetMethod(Mono.Collections.Generic.Collection methods, Mono.Cecil.MethodReference reference) { throw null; } public virtual Mono.Cecil.FieldDefinition Resolve(Mono.Cecil.FieldReference field) { throw null; } public virtual Mono.Cecil.MethodDefinition Resolve(Mono.Cecil.MethodReference method) { throw null; } public virtual Mono.Cecil.TypeDefinition Resolve(Mono.Cecil.TypeReference type) { throw null; } } public enum MetadataScopeType { AssemblyNameReference = 0, ModuleDefinition = 2, ModuleReference = 1, } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct MetadataToken : System.IEquatable { private int _dummyPrimitive; public static readonly Mono.Cecil.MetadataToken Zero; public MetadataToken(Mono.Cecil.TokenType type) { throw null; } public MetadataToken(Mono.Cecil.TokenType type, int rid) { throw null; } public MetadataToken(Mono.Cecil.TokenType type, uint rid) { throw null; } public MetadataToken(uint token) { throw null; } public uint RID { get { throw null; } } public Mono.Cecil.TokenType TokenType { get { throw null; } } public bool Equals(Mono.Cecil.MetadataToken other) { throw null; } public override bool Equals(object obj) { throw null; } public override int GetHashCode() { throw null; } public static bool operator ==(Mono.Cecil.MetadataToken one, Mono.Cecil.MetadataToken other) { throw null; } public static bool operator !=(Mono.Cecil.MetadataToken one, Mono.Cecil.MetadataToken other) { throw null; } public int ToInt32() { throw null; } public override string ToString() { throw null; } public uint ToUInt32() { throw null; } } public enum MetadataType : byte { Array = (byte)20, Boolean = (byte)2, ByReference = (byte)16, Byte = (byte)5, Char = (byte)3, Class = (byte)18, Double = (byte)13, FunctionPointer = (byte)27, GenericInstance = (byte)21, Int16 = (byte)6, Int32 = (byte)8, Int64 = (byte)10, IntPtr = (byte)24, MVar = (byte)30, Object = (byte)28, OptionalModifier = (byte)32, Pinned = (byte)69, Pointer = (byte)15, RequiredModifier = (byte)31, SByte = (byte)4, Sentinel = (byte)65, Single = (byte)12, String = (byte)14, TypedByReference = (byte)22, UInt16 = (byte)7, UInt32 = (byte)9, UInt64 = (byte)11, UIntPtr = (byte)25, ValueType = (byte)17, Var = (byte)19, Void = (byte)1, } [System.FlagsAttribute] public enum MethodAttributes : ushort { Abstract = (ushort)1024, Assembly = (ushort)3, CheckAccessOnOverride = (ushort)512, CompilerControlled = (ushort)0, FamANDAssem = (ushort)2, Family = (ushort)4, FamORAssem = (ushort)5, Final = (ushort)32, HasSecurity = (ushort)16384, HideBySig = (ushort)128, MemberAccessMask = (ushort)7, NewSlot = (ushort)256, PInvokeImpl = (ushort)8192, Private = (ushort)1, Public = (ushort)6, RequireSecObject = (ushort)32768, ReuseSlot = (ushort)0, RTSpecialName = (ushort)4096, SpecialName = (ushort)2048, Static = (ushort)16, UnmanagedExport = (ushort)8, Virtual = (ushort)64, VtableLayoutMask = (ushort)256, } public enum MethodCallingConvention : byte { C = (byte)1, Default = (byte)0, FastCall = (byte)4, Generic = (byte)16, StdCall = (byte)2, ThisCall = (byte)3, VarArg = (byte)5, } public sealed partial class MethodDefinition : Mono.Cecil.MethodReference, Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider { public MethodDefinition(string name, Mono.Cecil.MethodAttributes attributes, Mono.Cecil.TypeReference returnType) : base (default(string), default(Mono.Cecil.TypeReference)) { } public bool AggressiveInlining { get { throw null; } set { } } public Mono.Cecil.MethodAttributes Attributes { get { throw null; } set { } } public Mono.Cecil.Cil.MethodBody Body { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public Mono.Collections.Generic.Collection CustomDebugInformations { get { throw null; } } public Mono.Cecil.Cil.MethodDebugInformation DebugInformation { get { throw null; } set { } } public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } } public override Mono.Collections.Generic.Collection GenericParameters { get { throw null; } } public bool HasBody { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public bool HasCustomDebugInformations { get { throw null; } } public override bool HasGenericParameters { get { throw null; } } public bool HasOverrides { get { throw null; } } public bool HasPInvokeInfo { get { throw null; } } public bool HasSecurity { get { throw null; } set { } } public bool HasSecurityDeclarations { get { throw null; } } public Mono.Cecil.MethodImplAttributes ImplAttributes { get { throw null; } set { } } public bool IsAbstract { get { throw null; } set { } } public bool IsAddOn { get { throw null; } set { } } public bool IsAssembly { get { throw null; } set { } } public bool IsCheckAccessOnOverride { get { throw null; } set { } } public bool IsCompilerControlled { get { throw null; } set { } } public bool IsConstructor { get { throw null; } } public override bool IsDefinition { get { throw null; } } public bool IsFamily { get { throw null; } set { } } public bool IsFamilyAndAssembly { get { throw null; } set { } } public bool IsFamilyOrAssembly { get { throw null; } set { } } public bool IsFinal { get { throw null; } set { } } public bool IsFire { get { throw null; } set { } } public bool IsForwardRef { get { throw null; } set { } } public bool IsGetter { get { throw null; } set { } } public bool IsHideBySig { get { throw null; } set { } } public bool IsIL { get { throw null; } set { } } public bool IsInternalCall { get { throw null; } set { } } public bool IsManaged { get { throw null; } set { } } public bool IsNative { get { throw null; } set { } } public bool IsNewSlot { get { throw null; } set { } } public bool IsOther { get { throw null; } set { } } public bool IsPInvokeImpl { get { throw null; } set { } } public bool IsPreserveSig { get { throw null; } set { } } public bool IsPrivate { get { throw null; } set { } } public bool IsPublic { get { throw null; } set { } } public bool IsRemoveOn { get { throw null; } set { } } public bool IsReuseSlot { get { throw null; } set { } } public bool IsRuntime { get { throw null; } set { } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSetter { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public bool IsStatic { get { throw null; } set { } } public bool IsSynchronized { get { throw null; } set { } } public bool IsUnmanaged { get { throw null; } set { } } public bool IsUnmanagedExport { get { throw null; } set { } } public bool IsVirtual { get { throw null; } set { } } public override string Name { get { throw null; } set { } } public bool NoInlining { get { throw null; } set { } } public bool NoOptimization { get { throw null; } set { } } public Mono.Collections.Generic.Collection Overrides { get { throw null; } } public Mono.Cecil.PInvokeInfo PInvokeInfo { get { throw null; } set { } } public int RVA { get { throw null; } } public Mono.Collections.Generic.Collection SecurityDeclarations { get { throw null; } } public Mono.Cecil.MethodSemanticsAttributes SemanticsAttributes { get { throw null; } set { } } public override Mono.Cecil.MethodDefinition Resolve() { throw null; } } [System.FlagsAttribute] public enum MethodImplAttributes : ushort { AggressiveInlining = (ushort)256, CodeTypeMask = (ushort)3, ForwardRef = (ushort)16, IL = (ushort)0, InternalCall = (ushort)4096, Managed = (ushort)0, ManagedMask = (ushort)4, Native = (ushort)1, NoInlining = (ushort)8, NoOptimization = (ushort)64, OPTIL = (ushort)2, PreserveSig = (ushort)128, Runtime = (ushort)3, Synchronized = (ushort)32, Unmanaged = (ushort)4, } public partial class MethodReference : Mono.Cecil.MemberReference, Mono.Cecil.IGenericParameterProvider, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.IMethodSignature { public MethodReference(string name, Mono.Cecil.TypeReference returnType) { } public MethodReference(string name, Mono.Cecil.TypeReference returnType, Mono.Cecil.TypeReference declaringType) { } public virtual Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } } public override bool ContainsGenericParameter { get { throw null; } } public virtual bool ExplicitThis { get { throw null; } set { } } public override string FullName { get { throw null; } } public virtual Mono.Collections.Generic.Collection GenericParameters { get { throw null; } } public virtual bool HasGenericParameters { get { throw null; } } public virtual bool HasParameters { get { throw null; } } public virtual bool HasThis { get { throw null; } set { } } public virtual bool IsGenericInstance { get { throw null; } } public virtual Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } set { } } Mono.Cecil.GenericParameterType Mono.Cecil.IGenericParameterProvider.GenericParameterType { get { throw null; } } public virtual Mono.Collections.Generic.Collection Parameters { get { throw null; } } public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } } public virtual Mono.Cecil.MethodReference GetElementMethod() { throw null; } public virtual new Mono.Cecil.MethodDefinition Resolve() { throw null; } protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; } } public sealed partial class MethodReturnType : Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMetadataTokenProvider { public MethodReturnType(Mono.Cecil.IMethodSignature method) { } public Mono.Cecil.ParameterAttributes Attributes { get { throw null; } set { } } public object Constant { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public bool HasConstant { get { throw null; } set { } } public bool HasCustomAttributes { get { throw null; } } public bool HasDefault { get { throw null; } set { } } public bool HasFieldMarshal { get { throw null; } set { } } public bool HasMarshalInfo { get { throw null; } } public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public Mono.Cecil.IMethodSignature Method { get { throw null; } } public string Name { get { throw null; } set { } } public Mono.Cecil.TypeReference ReturnType { get { throw null; } set { } } } [System.FlagsAttribute] public enum MethodSemanticsAttributes : ushort { AddOn = (ushort)8, Fire = (ushort)32, Getter = (ushort)2, None = (ushort)0, Other = (ushort)4, RemoveOn = (ushort)16, Setter = (ushort)1, } public abstract partial class MethodSpecification : Mono.Cecil.MethodReference { internal MethodSpecification() : base (default(string), default(Mono.Cecil.TypeReference)) { } public override Mono.Cecil.MethodCallingConvention CallingConvention { get { throw null; } set { } } public override bool ContainsGenericParameter { get { throw null; } } public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } } public Mono.Cecil.MethodReference ElementMethod { get { throw null; } } public override bool ExplicitThis { get { throw null; } set { } } public override bool HasParameters { get { throw null; } } public override bool HasThis { get { throw null; } set { } } public override Mono.Cecil.MethodReturnType MethodReturnType { get { throw null; } set { } } public override Mono.Cecil.ModuleDefinition Module { get { throw null; } } public override string Name { get { throw null; } set { } } public override Mono.Collections.Generic.Collection Parameters { get { throw null; } } public sealed override Mono.Cecil.MethodReference GetElementMethod() { throw null; } } [System.FlagsAttribute] public enum ModuleAttributes { ILLibrary = 4, ILOnly = 1, Preferred32Bit = 131072, Required32Bit = 2, StrongNameSigned = 8, } [System.FlagsAttribute] public enum ModuleCharacteristics { AppContainer = 4096, DynamicBase = 64, HighEntropyVA = 32, NoSEH = 1024, NXCompat = 256, TerminalServerAware = 32768, } public sealed partial class ModuleDefinition : Mono.Cecil.ModuleReference, Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMetadataTokenProvider, System.IDisposable { internal ModuleDefinition() : base (default(string)) { } public Mono.Cecil.TargetArchitecture Architecture { get { throw null; } set { } } public Mono.Cecil.AssemblyDefinition Assembly { get { throw null; } } public Mono.Collections.Generic.Collection AssemblyReferences { get { throw null; } } public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } } public Mono.Cecil.ModuleAttributes Attributes { get { throw null; } set { } } public Mono.Cecil.ModuleCharacteristics Characteristics { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public Mono.Collections.Generic.Collection CustomDebugInformations { get { throw null; } } public Mono.Cecil.MethodDefinition EntryPoint { get { throw null; } set { } } public Mono.Collections.Generic.Collection ExportedTypes { get { throw null; } } public string FileName { get { throw null; } } [System.ObsoleteAttribute("Use FileName")] public string FullyQualifiedName { get { throw null; } } public bool HasAssemblyReferences { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public bool HasCustomDebugInformations { get { throw null; } } public bool HasDebugHeader { get { throw null; } } public bool HasExportedTypes { get { throw null; } } public bool HasModuleReferences { get { throw null; } } public bool HasResources { get { throw null; } } public bool HasSymbols { get { throw null; } } public bool HasTypes { get { throw null; } } public bool IsMain { get { throw null; } } public Mono.Cecil.ModuleKind Kind { get { throw null; } set { } } public Mono.Cecil.MetadataKind MetadataKind { get { throw null; } set { } } public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } } public override Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } } public Mono.Collections.Generic.Collection ModuleReferences { get { throw null; } } public System.Guid Mvid { get { throw null; } set { } } public Mono.Collections.Generic.Collection Resources { get { throw null; } } public Mono.Cecil.TargetRuntime Runtime { get { throw null; } set { } } public string RuntimeVersion { get { throw null; } set { } } public Mono.Cecil.Cil.ISymbolReader SymbolReader { get { throw null; } } public Mono.Collections.Generic.Collection Types { get { throw null; } } public Mono.Cecil.TypeSystem TypeSystem { get { throw null; } } public static Mono.Cecil.ModuleDefinition CreateModule(string name, Mono.Cecil.ModuleKind kind) { throw null; } public static Mono.Cecil.ModuleDefinition CreateModule(string name, Mono.Cecil.ModuleParameters parameters) { throw null; } public void Dispose() { } public System.Collections.Generic.IEnumerable GetCustomAttributes() { throw null; } public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; } public System.Collections.Generic.IEnumerable GetMemberReferences() { throw null; } public Mono.Cecil.TypeDefinition GetType(string fullName) { throw null; } public Mono.Cecil.TypeReference GetType(string fullName, bool runtimeName) { throw null; } public Mono.Cecil.TypeDefinition GetType(string @namespace, string name) { throw null; } public System.Collections.Generic.IEnumerable GetTypeReferences() { throw null; } public System.Collections.Generic.IEnumerable GetTypes() { throw null; } public bool HasTypeReference(string fullName) { throw null; } public bool HasTypeReference(string scope, string fullName) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.FieldReference Import(Mono.Cecil.FieldReference field) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.FieldReference Import(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.MethodReference Import(Mono.Cecil.MethodReference method) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.MethodReference Import(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.TypeReference Import(Mono.Cecil.TypeReference type) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.TypeReference Import(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.FieldReference Import(System.Reflection.FieldInfo field) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.FieldReference Import(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.MethodReference Import(System.Reflection.MethodBase method) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.MethodReference Import(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.TypeReference Import(System.Type type) { throw null; } [System.ObsoleteAttribute("Use ImportReference", false)] public Mono.Cecil.TypeReference Import(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field) { throw null; } public Mono.Cecil.FieldReference ImportReference(Mono.Cecil.FieldReference field, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method) { throw null; } public Mono.Cecil.MethodReference ImportReference(Mono.Cecil.MethodReference method, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type) { throw null; } public Mono.Cecil.TypeReference ImportReference(Mono.Cecil.TypeReference type, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field) { throw null; } public Mono.Cecil.FieldReference ImportReference(System.Reflection.FieldInfo field, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method) { throw null; } public Mono.Cecil.MethodReference ImportReference(System.Reflection.MethodBase method, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.TypeReference ImportReference(System.Type type) { throw null; } public Mono.Cecil.TypeReference ImportReference(System.Type type, Mono.Cecil.IGenericParameterProvider context) { throw null; } public Mono.Cecil.IMetadataTokenProvider LookupToken(Mono.Cecil.MetadataToken token) { throw null; } public Mono.Cecil.IMetadataTokenProvider LookupToken(int token) { throw null; } public static Mono.Cecil.ModuleDefinition ReadModule(System.IO.Stream stream) { throw null; } public static Mono.Cecil.ModuleDefinition ReadModule(System.IO.Stream stream, Mono.Cecil.ReaderParameters parameters) { throw null; } public static Mono.Cecil.ModuleDefinition ReadModule(string fileName) { throw null; } public static Mono.Cecil.ModuleDefinition ReadModule(string fileName, Mono.Cecil.ReaderParameters parameters) { throw null; } public void ReadSymbols() { } public void ReadSymbols(Mono.Cecil.Cil.ISymbolReader reader) { } public void ReadSymbols(Mono.Cecil.Cil.ISymbolReader reader, bool throwIfSymbolsAreNotMaching) { } public bool TryGetTypeReference(string fullName, out Mono.Cecil.TypeReference type) { throw null; } public bool TryGetTypeReference(string scope, string fullName, out Mono.Cecil.TypeReference type) { throw null; } public void Write() { } public void Write(Mono.Cecil.WriterParameters parameters) { } public void Write(System.IO.Stream stream) { } public void Write(System.IO.Stream stream, Mono.Cecil.WriterParameters parameters) { } public void Write(string fileName) { } public void Write(string fileName, Mono.Cecil.WriterParameters parameters) { } } public enum ModuleKind { Console = 1, Dll = 0, NetModule = 3, Windows = 2, } public sealed partial class ModuleParameters { public ModuleParameters() { } public Mono.Cecil.TargetArchitecture Architecture { get { throw null; } set { } } public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } set { } } public Mono.Cecil.ModuleKind Kind { get { throw null; } set { } } public Mono.Cecil.IMetadataImporterProvider MetadataImporterProvider { get { throw null; } set { } } public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } set { } } public Mono.Cecil.IReflectionImporterProvider ReflectionImporterProvider { get { throw null; } set { } } public Mono.Cecil.TargetRuntime Runtime { get { throw null; } set { } } public System.Nullable Timestamp { get { throw null; } set { } } } public partial class ModuleReference : Mono.Cecil.IMetadataScope, Mono.Cecil.IMetadataTokenProvider { public ModuleReference(string name) { } public virtual Mono.Cecil.MetadataScopeType MetadataScopeType { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public string Name { get { throw null; } set { } } public override string ToString() { throw null; } } public enum NativeType { ANSIBStr = 35, Array = 42, ASAny = 40, Boolean = 2, BStr = 19, ByValStr = 34, Currency = 15, CustomMarshaler = 44, Error = 45, FixedArray = 30, FixedSysString = 23, Func = 38, I1 = 3, I2 = 5, I4 = 7, I8 = 9, IDispatch = 26, Int = 31, IntF = 28, IUnknown = 25, LPStr = 20, LPStruct = 43, LPTStr = 22, LPWStr = 21, Max = 80, None = 102, R4 = 11, R8 = 12, SafeArray = 29, Struct = 27, TBStr = 36, U1 = 4, U2 = 6, U4 = 8, U8 = 10, UInt = 32, VariantBool = 37, } public sealed partial class OptionalModifierType : Mono.Cecil.TypeSpecification, Mono.Cecil.IModifierType { public OptionalModifierType(Mono.Cecil.TypeReference modifierType, Mono.Cecil.TypeReference type) { } public override bool ContainsGenericParameter { get { throw null; } } public override string FullName { get { throw null; } } public override bool IsOptionalModifier { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } public Mono.Cecil.TypeReference ModifierType { get { throw null; } set { } } public override string Name { get { throw null; } } } [System.FlagsAttribute] public enum ParameterAttributes : ushort { HasDefault = (ushort)4096, HasFieldMarshal = (ushort)8192, In = (ushort)1, Lcid = (ushort)4, None = (ushort)0, Optional = (ushort)16, Out = (ushort)2, Retval = (ushort)8, Unused = (ushort)53216, } public sealed partial class ParameterDefinition : Mono.Cecil.ParameterReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMarshalInfoProvider, Mono.Cecil.IMetadataTokenProvider { public ParameterDefinition(Mono.Cecil.TypeReference parameterType) { } public ParameterDefinition(string name, Mono.Cecil.ParameterAttributes attributes, Mono.Cecil.TypeReference parameterType) { } public Mono.Cecil.ParameterAttributes Attributes { get { throw null; } set { } } public object Constant { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public bool HasConstant { get { throw null; } set { } } public bool HasCustomAttributes { get { throw null; } } public bool HasDefault { get { throw null; } set { } } public bool HasFieldMarshal { get { throw null; } set { } } public bool HasMarshalInfo { get { throw null; } } public bool IsIn { get { throw null; } set { } } public bool IsLcid { get { throw null; } set { } } public bool IsOptional { get { throw null; } set { } } public bool IsOut { get { throw null; } set { } } public bool IsReturnValue { get { throw null; } set { } } public Mono.Cecil.MarshalInfo MarshalInfo { get { throw null; } set { } } public Mono.Cecil.IMethodSignature Method { get { throw null; } } public int Sequence { get { throw null; } } public override Mono.Cecil.ParameterDefinition Resolve() { throw null; } } public abstract partial class ParameterReference : Mono.Cecil.IMetadataTokenProvider { internal ParameterReference() { } protected Mono.Cecil.TypeReference parameter_type; public int Index { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } public string Name { get { throw null; } set { } } public Mono.Cecil.TypeReference ParameterType { get { throw null; } set { } } public abstract Mono.Cecil.ParameterDefinition Resolve(); public override string ToString() { throw null; } } public sealed partial class PinnedType : Mono.Cecil.TypeSpecification { public PinnedType(Mono.Cecil.TypeReference type) { } public override bool IsPinned { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } } [System.FlagsAttribute] public enum PInvokeAttributes : ushort { BestFitDisabled = (ushort)32, BestFitEnabled = (ushort)16, BestFitMask = (ushort)48, CallConvCdecl = (ushort)512, CallConvFastcall = (ushort)1280, CallConvMask = (ushort)1792, CallConvStdCall = (ushort)768, CallConvThiscall = (ushort)1024, CallConvWinapi = (ushort)256, CharSetAnsi = (ushort)2, CharSetAuto = (ushort)6, CharSetMask = (ushort)6, CharSetNotSpec = (ushort)0, CharSetUnicode = (ushort)4, NoMangle = (ushort)1, SupportsLastError = (ushort)64, ThrowOnUnmappableCharDisabled = (ushort)8192, ThrowOnUnmappableCharEnabled = (ushort)4096, ThrowOnUnmappableCharMask = (ushort)12288, } public sealed partial class PInvokeInfo { public PInvokeInfo(Mono.Cecil.PInvokeAttributes attributes, string entryPoint, Mono.Cecil.ModuleReference module) { } public Mono.Cecil.PInvokeAttributes Attributes { get { throw null; } set { } } public string EntryPoint { get { throw null; } set { } } public bool IsBestFitDisabled { get { throw null; } set { } } public bool IsBestFitEnabled { get { throw null; } set { } } public bool IsCallConvCdecl { get { throw null; } set { } } public bool IsCallConvFastcall { get { throw null; } set { } } public bool IsCallConvStdCall { get { throw null; } set { } } public bool IsCallConvThiscall { get { throw null; } set { } } public bool IsCallConvWinapi { get { throw null; } set { } } public bool IsCharSetAnsi { get { throw null; } set { } } public bool IsCharSetAuto { get { throw null; } set { } } public bool IsCharSetNotSpec { get { throw null; } set { } } public bool IsCharSetUnicode { get { throw null; } set { } } public bool IsNoMangle { get { throw null; } set { } } public bool IsThrowOnUnmappableCharDisabled { get { throw null; } set { } } public bool IsThrowOnUnmappableCharEnabled { get { throw null; } set { } } public Mono.Cecil.ModuleReference Module { get { throw null; } set { } } public bool SupportsLastError { get { throw null; } set { } } } public sealed partial class PointerType : Mono.Cecil.TypeSpecification { public PointerType(Mono.Cecil.TypeReference type) { } public override string FullName { get { throw null; } } public override bool IsPointer { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } public override string Name { get { throw null; } } } [System.FlagsAttribute] public enum PropertyAttributes : ushort { HasDefault = (ushort)4096, None = (ushort)0, RTSpecialName = (ushort)1024, SpecialName = (ushort)512, Unused = (ushort)59903, } public sealed partial class PropertyDefinition : Mono.Cecil.PropertyReference, Mono.Cecil.IConstantProvider, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider { public PropertyDefinition(string name, Mono.Cecil.PropertyAttributes attributes, Mono.Cecil.TypeReference propertyType) { } public Mono.Cecil.PropertyAttributes Attributes { get { throw null; } set { } } public object Constant { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } } public override string FullName { get { throw null; } } public Mono.Cecil.MethodDefinition GetMethod { get { throw null; } set { } } public bool HasConstant { get { throw null; } set { } } public bool HasCustomAttributes { get { throw null; } } public bool HasDefault { get { throw null; } set { } } public bool HasOtherMethods { get { throw null; } } public bool HasParameters { get { throw null; } } public bool HasThis { get { throw null; } set { } } public override bool IsDefinition { get { throw null; } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public Mono.Collections.Generic.Collection OtherMethods { get { throw null; } } public override Mono.Collections.Generic.Collection Parameters { get { throw null; } } public Mono.Cecil.MethodDefinition SetMethod { get { throw null; } set { } } public override Mono.Cecil.PropertyDefinition Resolve() { throw null; } } public abstract partial class PropertyReference : Mono.Cecil.MemberReference { internal PropertyReference() { } public abstract Mono.Collections.Generic.Collection Parameters { get; } public Mono.Cecil.TypeReference PropertyType { get { throw null; } set { } } public abstract new Mono.Cecil.PropertyDefinition Resolve(); protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; } } public sealed partial class ReaderParameters { public ReaderParameters() { } public ReaderParameters(Mono.Cecil.ReadingMode readingMode) { } public bool ApplyWindowsRuntimeProjections { get { throw null; } set { } } public Mono.Cecil.IAssemblyResolver AssemblyResolver { get { throw null; } set { } } public bool InMemory { get { throw null; } set { } } public Mono.Cecil.IMetadataImporterProvider MetadataImporterProvider { get { throw null; } set { } } public Mono.Cecil.IMetadataResolver MetadataResolver { get { throw null; } set { } } public Mono.Cecil.ReadingMode ReadingMode { get { throw null; } set { } } public bool ReadSymbols { get { throw null; } set { } } public bool ReadWrite { get { throw null; } set { } } public Mono.Cecil.IReflectionImporterProvider ReflectionImporterProvider { get { throw null; } set { } } public Mono.Cecil.Cil.ISymbolReaderProvider SymbolReaderProvider { get { throw null; } set { } } public System.IO.Stream SymbolStream { get { throw null; } set { } } public bool ThrowIfSymbolsAreNotMatching { get { throw null; } set { } } } public enum ReadingMode { Deferred = 2, Immediate = 1, } public sealed partial class RequiredModifierType : Mono.Cecil.TypeSpecification, Mono.Cecil.IModifierType { public RequiredModifierType(Mono.Cecil.TypeReference modifierType, Mono.Cecil.TypeReference type) { } public override bool ContainsGenericParameter { get { throw null; } } public override string FullName { get { throw null; } } public override bool IsRequiredModifier { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } public Mono.Cecil.TypeReference ModifierType { get { throw null; } set { } } public override string Name { get { throw null; } } } [System.SerializableAttribute] public sealed partial class ResolutionException : System.Exception { public ResolutionException(Mono.Cecil.MemberReference member) { } public ResolutionException(Mono.Cecil.MemberReference member, System.Exception innerException) { } public Mono.Cecil.MemberReference Member { get { throw null; } } public Mono.Cecil.IMetadataScope Scope { get { throw null; } } } public abstract partial class Resource { internal Resource() { } public Mono.Cecil.ManifestResourceAttributes Attributes { get { throw null; } set { } } public bool IsPrivate { get { throw null; } set { } } public bool IsPublic { get { throw null; } set { } } public string Name { get { throw null; } set { } } public abstract Mono.Cecil.ResourceType ResourceType { get; } } public enum ResourceType { AssemblyLinked = 2, Embedded = 1, Linked = 0, } public sealed partial class SafeArrayMarshalInfo : Mono.Cecil.MarshalInfo { public SafeArrayMarshalInfo() : base (default(Mono.Cecil.NativeType)) { } public Mono.Cecil.VariantType ElementType { get { throw null; } set { } } } public enum SecurityAction : ushort { Assert = (ushort)3, Demand = (ushort)2, Deny = (ushort)4, InheritDemand = (ushort)7, LinkDemand = (ushort)6, NonCasDemand = (ushort)13, NonCasInheritance = (ushort)15, NonCasLinkDemand = (ushort)14, PermitOnly = (ushort)5, PreJitDeny = (ushort)12, PreJitGrant = (ushort)11, Request = (ushort)1, RequestMinimum = (ushort)8, RequestOptional = (ushort)9, RequestRefuse = (ushort)10, } [System.Diagnostics.DebuggerDisplayAttribute("{AttributeType}")] public sealed partial class SecurityAttribute : Mono.Cecil.ICustomAttribute { public SecurityAttribute(Mono.Cecil.TypeReference attributeType) { } public Mono.Cecil.TypeReference AttributeType { get { throw null; } set { } } public Mono.Collections.Generic.Collection Fields { get { throw null; } } public bool HasFields { get { throw null; } } public bool HasProperties { get { throw null; } } Mono.Collections.Generic.Collection Mono.Cecil.ICustomAttribute.ConstructorArguments { get { throw null; } } bool Mono.Cecil.ICustomAttribute.HasConstructorArguments { get { throw null; } } public Mono.Collections.Generic.Collection Properties { get { throw null; } } } public sealed partial class SecurityDeclaration { public SecurityDeclaration(Mono.Cecil.SecurityAction action) { } public SecurityDeclaration(Mono.Cecil.SecurityAction action, byte[] blob) { } public Mono.Cecil.SecurityAction Action { get { throw null; } set { } } public bool HasSecurityAttributes { get { throw null; } } public Mono.Collections.Generic.Collection SecurityAttributes { get { throw null; } } public byte[] GetBlob() { throw null; } } public sealed partial class SentinelType : Mono.Cecil.TypeSpecification { public SentinelType(Mono.Cecil.TypeReference type) { } public override bool IsSentinel { get { throw null; } } public override bool IsValueType { get { throw null; } set { } } } public enum TargetArchitecture { AMD64 = 34404, ARM = 448, ARM64 = 43620, ARMv7 = 452, I386 = 332, IA64 = 512, } public enum TargetRuntime { Net_1_0 = 0, Net_1_1 = 1, Net_2_0 = 2, Net_4_0 = 3, } public enum TokenType : uint { Assembly = (uint)536870912, AssemblyRef = (uint)587202560, CustomAttribute = (uint)201326592, CustomDebugInformation = (uint)922746880, Document = (uint)805306368, Event = (uint)335544320, ExportedType = (uint)654311424, Field = (uint)67108864, File = (uint)637534208, GenericParam = (uint)704643072, GenericParamConstraint = (uint)738197504, ImportScope = (uint)889192448, InterfaceImpl = (uint)150994944, LocalConstant = (uint)872415232, LocalScope = (uint)838860800, LocalVariable = (uint)855638016, ManifestResource = (uint)671088640, MemberRef = (uint)167772160, Method = (uint)100663296, MethodDebugInformation = (uint)822083584, MethodSpec = (uint)721420288, Module = (uint)0, ModuleRef = (uint)436207616, Param = (uint)134217728, Permission = (uint)234881024, Property = (uint)385875968, Signature = (uint)285212672, StateMachineMethod = (uint)905969664, String = (uint)1879048192, TypeDef = (uint)33554432, TypeRef = (uint)16777216, TypeSpec = (uint)452984832, } [System.FlagsAttribute] public enum TypeAttributes : uint { Abstract = (uint)128, AnsiClass = (uint)0, AutoClass = (uint)131072, AutoLayout = (uint)0, BeforeFieldInit = (uint)1048576, Class = (uint)0, ClassSemanticMask = (uint)32, ExplicitLayout = (uint)16, Forwarder = (uint)2097152, HasSecurity = (uint)262144, Import = (uint)4096, Interface = (uint)32, LayoutMask = (uint)24, NestedAssembly = (uint)5, NestedFamANDAssem = (uint)6, NestedFamily = (uint)4, NestedFamORAssem = (uint)7, NestedPrivate = (uint)3, NestedPublic = (uint)2, NotPublic = (uint)0, Public = (uint)1, RTSpecialName = (uint)2048, Sealed = (uint)256, SequentialLayout = (uint)8, Serializable = (uint)8192, SpecialName = (uint)1024, StringFormatMask = (uint)196608, UnicodeClass = (uint)65536, VisibilityMask = (uint)7, WindowsRuntime = (uint)16384, } public sealed partial class TypeDefinition : Mono.Cecil.TypeReference, Mono.Cecil.ICustomAttributeProvider, Mono.Cecil.IMemberDefinition, Mono.Cecil.IMetadataTokenProvider, Mono.Cecil.ISecurityDeclarationProvider { public TypeDefinition(string @namespace, string name, Mono.Cecil.TypeAttributes attributes) : base (default(string), default(string)) { } public TypeDefinition(string @namespace, string name, Mono.Cecil.TypeAttributes attributes, Mono.Cecil.TypeReference baseType) : base (default(string), default(string)) { } public Mono.Cecil.TypeAttributes Attributes { get { throw null; } set { } } public Mono.Cecil.TypeReference BaseType { get { throw null; } set { } } public int ClassSize { get { throw null; } set { } } public Mono.Collections.Generic.Collection CustomAttributes { get { throw null; } } public new Mono.Cecil.TypeDefinition DeclaringType { get { throw null; } set { } } public Mono.Collections.Generic.Collection Events { get { throw null; } } public Mono.Collections.Generic.Collection Fields { get { throw null; } } public override Mono.Collections.Generic.Collection GenericParameters { get { throw null; } } public bool HasCustomAttributes { get { throw null; } } public bool HasEvents { get { throw null; } } public bool HasFields { get { throw null; } } public override bool HasGenericParameters { get { throw null; } } public bool HasInterfaces { get { throw null; } } public bool HasLayoutInfo { get { throw null; } } public bool HasMethods { get { throw null; } } public bool HasNestedTypes { get { throw null; } } public bool HasProperties { get { throw null; } } public bool HasSecurity { get { throw null; } set { } } public bool HasSecurityDeclarations { get { throw null; } } public Mono.Collections.Generic.Collection Interfaces { get { throw null; } } public bool IsAbstract { get { throw null; } set { } } public bool IsAnsiClass { get { throw null; } set { } } public bool IsAutoClass { get { throw null; } set { } } public bool IsAutoLayout { get { throw null; } set { } } public bool IsBeforeFieldInit { get { throw null; } set { } } public bool IsClass { get { throw null; } set { } } public override bool IsDefinition { get { throw null; } } public bool IsEnum { get { throw null; } } public bool IsExplicitLayout { get { throw null; } set { } } public bool IsImport { get { throw null; } set { } } public bool IsInterface { get { throw null; } set { } } public bool IsNestedAssembly { get { throw null; } set { } } public bool IsNestedFamily { get { throw null; } set { } } public bool IsNestedFamilyAndAssembly { get { throw null; } set { } } public bool IsNestedFamilyOrAssembly { get { throw null; } set { } } public bool IsNestedPrivate { get { throw null; } set { } } public bool IsNestedPublic { get { throw null; } set { } } public bool IsNotPublic { get { throw null; } set { } } public override bool IsPrimitive { get { throw null; } } public bool IsPublic { get { throw null; } set { } } public bool IsRuntimeSpecialName { get { throw null; } set { } } public bool IsSealed { get { throw null; } set { } } public bool IsSequentialLayout { get { throw null; } set { } } public bool IsSerializable { get { throw null; } set { } } public bool IsSpecialName { get { throw null; } set { } } public bool IsUnicodeClass { get { throw null; } set { } } public override bool IsValueType { get { throw null; } set { } } public bool IsWindowsRuntime { get { throw null; } set { } } public override Mono.Cecil.MetadataType MetadataType { get { throw null; } } public Mono.Collections.Generic.Collection Methods { get { throw null; } } public override string Name { get { throw null; } set { } } public Mono.Collections.Generic.Collection NestedTypes { get { throw null; } } public short PackingSize { get { throw null; } set { } } public Mono.Collections.Generic.Collection Properties { get { throw null; } } public Mono.Collections.Generic.Collection SecurityDeclarations { get { throw null; } } protected override void ClearFullName() { } public override Mono.Cecil.TypeDefinition Resolve() { throw null; } } public partial class TypeReference : Mono.Cecil.MemberReference, Mono.Cecil.IGenericParameterProvider, Mono.Cecil.IMetadataTokenProvider { protected Mono.Collections.Generic.Collection generic_parameters; protected TypeReference(string @namespace, string name) { } public TypeReference(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope) { } public TypeReference(string @namespace, string name, Mono.Cecil.ModuleDefinition module, Mono.Cecil.IMetadataScope scope, bool valueType) { } public override Mono.Cecil.TypeReference DeclaringType { get { throw null; } set { } } public override string FullName { get { throw null; } } public virtual Mono.Collections.Generic.Collection GenericParameters { get { throw null; } } public virtual bool HasGenericParameters { get { throw null; } } public virtual bool IsArray { get { throw null; } } public virtual bool IsByReference { get { throw null; } } public virtual bool IsFunctionPointer { get { throw null; } } public virtual bool IsGenericInstance { get { throw null; } } public virtual bool IsGenericParameter { get { throw null; } } public bool IsNested { get { throw null; } } public virtual bool IsOptionalModifier { get { throw null; } } public virtual bool IsPinned { get { throw null; } } public virtual bool IsPointer { get { throw null; } } public virtual bool IsPrimitive { get { throw null; } } public virtual bool IsRequiredModifier { get { throw null; } } public virtual bool IsSentinel { get { throw null; } } public virtual bool IsValueType { get { throw null; } set { } } public virtual Mono.Cecil.MetadataType MetadataType { get { throw null; } } public override Mono.Cecil.ModuleDefinition Module { get { throw null; } } Mono.Cecil.GenericParameterType Mono.Cecil.IGenericParameterProvider.GenericParameterType { get { throw null; } } public override string Name { get { throw null; } set { } } public virtual string Namespace { get { throw null; } set { } } public virtual Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } } protected virtual void ClearFullName() { } public virtual Mono.Cecil.TypeReference GetElementType() { throw null; } public virtual new Mono.Cecil.TypeDefinition Resolve() { throw null; } protected override Mono.Cecil.IMemberDefinition ResolveDefinition() { throw null; } } public abstract partial class TypeSpecification : Mono.Cecil.TypeReference { internal TypeSpecification() : base (default(string), default(string)) { } public override bool ContainsGenericParameter { get { throw null; } } public Mono.Cecil.TypeReference ElementType { get { throw null; } } public override string FullName { get { throw null; } } public override Mono.Cecil.MetadataType MetadataType { get { throw null; } } public override Mono.Cecil.ModuleDefinition Module { get { throw null; } } public override string Name { get { throw null; } set { } } public override string Namespace { get { throw null; } set { } } public override Mono.Cecil.IMetadataScope Scope { get { throw null; } set { } } public override Mono.Cecil.TypeReference GetElementType() { throw null; } } public abstract partial class TypeSystem { internal TypeSystem() { } public Mono.Cecil.TypeReference Boolean { get { throw null; } } public Mono.Cecil.TypeReference Byte { get { throw null; } } public Mono.Cecil.TypeReference Char { get { throw null; } } public Mono.Cecil.IMetadataScope CoreLibrary { get { throw null; } } [System.ObsoleteAttribute("Use CoreLibrary")] public Mono.Cecil.IMetadataScope Corlib { get { throw null; } } public Mono.Cecil.TypeReference Double { get { throw null; } } public Mono.Cecil.TypeReference Int16 { get { throw null; } } public Mono.Cecil.TypeReference Int32 { get { throw null; } } public Mono.Cecil.TypeReference Int64 { get { throw null; } } public Mono.Cecil.TypeReference IntPtr { get { throw null; } } public Mono.Cecil.TypeReference Object { get { throw null; } } public Mono.Cecil.TypeReference SByte { get { throw null; } } public Mono.Cecil.TypeReference Single { get { throw null; } } public Mono.Cecil.TypeReference String { get { throw null; } } public Mono.Cecil.TypeReference TypedReference { get { throw null; } } public Mono.Cecil.TypeReference UInt16 { get { throw null; } } public Mono.Cecil.TypeReference UInt32 { get { throw null; } } public Mono.Cecil.TypeReference UInt64 { get { throw null; } } public Mono.Cecil.TypeReference UIntPtr { get { throw null; } } public Mono.Cecil.TypeReference Void { get { throw null; } } } public enum VariantType { Bool = 11, BStr = 8, CY = 6, Date = 7, Decimal = 14, Dispatch = 9, Error = 10, I1 = 16, I2 = 2, I4 = 3, I8 = 20, Int = 22, None = 0, R4 = 4, R8 = 5, UI1 = 17, UI2 = 18, UI4 = 19, UI8 = 21, UInt = 23, Unknown = 13, Variant = 12, } public sealed partial class WriterParameters { public WriterParameters() { } public bool DeterministicMvid { get { throw null; } set { } } public bool HasStrongNameKey { get { throw null; } } public byte[] StrongNameKeyBlob { get { throw null; } set { } } public string StrongNameKeyContainer { get { throw null; } set { } } public System.Reflection.StrongNameKeyPair StrongNameKeyPair { get { throw null; } set { } } public System.IO.Stream SymbolStream { get { throw null; } set { } } public Mono.Cecil.Cil.ISymbolWriterProvider SymbolWriterProvider { get { throw null; } set { } } public System.Nullable Timestamp { get { throw null; } set { } } public bool WriteSymbols { get { throw null; } set { } } } } namespace Mono.Cecil.Cil { public sealed partial class AsyncMethodBodyDebugInformation : Mono.Cecil.Cil.CustomDebugInformation { public static System.Guid KindIdentifier; public AsyncMethodBodyDebugInformation() { } public AsyncMethodBodyDebugInformation(Mono.Cecil.Cil.Instruction catchHandler) { } public Mono.Cecil.Cil.InstructionOffset CatchHandler { get { throw null; } set { } } public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } } public Mono.Collections.Generic.Collection ResumeMethods { get { throw null; } } public Mono.Collections.Generic.Collection Resumes { get { throw null; } } public Mono.Collections.Generic.Collection Yields { get { throw null; } } } public sealed partial class BinaryCustomDebugInformation : Mono.Cecil.Cil.CustomDebugInformation { public BinaryCustomDebugInformation(System.Guid identifier, byte[] data) { } public byte[] Data { get { throw null; } set { } } public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } } } public enum Code { Add = 87, Add_Ovf = 180, Add_Ovf_Un = 181, And = 94, Arglist = 191, Beq = 58, Beq_S = 45, Bge = 59, Bge_S = 46, Bge_Un = 64, Bge_Un_S = 51, Bgt = 60, Bgt_S = 47, Bgt_Un = 65, Bgt_Un_S = 52, Ble = 61, Ble_S = 48, Ble_Un = 66, Ble_Un_S = 53, Blt = 62, Blt_S = 49, Blt_Un = 67, Blt_Un_S = 54, Bne_Un = 63, Bne_Un_S = 50, Box = 137, Br = 55, Break = 1, Brfalse = 56, Brfalse_S = 43, Brtrue = 57, Brtrue_S = 44, Br_S = 42, Call = 39, Calli = 40, Callvirt = 110, Castclass = 115, Ceq = 192, Cgt = 193, Cgt_Un = 194, Ckfinite = 172, Clt = 195, Clt_Un = 196, Constrained = 211, Conv_I = 177, Conv_I1 = 102, Conv_I2 = 103, Conv_I4 = 104, Conv_I8 = 105, Conv_Ovf_I = 178, Conv_Ovf_I1 = 163, Conv_Ovf_I1_Un = 127, Conv_Ovf_I2 = 165, Conv_Ovf_I2_Un = 128, Conv_Ovf_I4 = 167, Conv_Ovf_I4_Un = 129, Conv_Ovf_I8 = 169, Conv_Ovf_I8_Un = 130, Conv_Ovf_I_Un = 135, Conv_Ovf_U = 179, Conv_Ovf_U1 = 164, Conv_Ovf_U1_Un = 131, Conv_Ovf_U2 = 166, Conv_Ovf_U2_Un = 132, Conv_Ovf_U4 = 168, Conv_Ovf_U4_Un = 133, Conv_Ovf_U8 = 170, Conv_Ovf_U8_Un = 134, Conv_Ovf_U_Un = 136, Conv_R4 = 106, Conv_R8 = 107, Conv_R_Un = 117, Conv_U = 190, Conv_U1 = 176, Conv_U2 = 175, Conv_U4 = 108, Conv_U8 = 109, Cpblk = 212, Cpobj = 111, Div = 90, Div_Un = 91, Dup = 36, Endfilter = 206, Endfinally = 186, Initblk = 213, Initobj = 210, Isinst = 116, Jmp = 38, Ldarg = 199, Ldarga = 200, Ldarga_S = 15, Ldarg_0 = 2, Ldarg_1 = 3, Ldarg_2 = 4, Ldarg_3 = 5, Ldarg_S = 14, Ldc_I4 = 32, Ldc_I4_0 = 22, Ldc_I4_1 = 23, Ldc_I4_2 = 24, Ldc_I4_3 = 25, Ldc_I4_4 = 26, Ldc_I4_5 = 27, Ldc_I4_6 = 28, Ldc_I4_7 = 29, Ldc_I4_8 = 30, Ldc_I4_M1 = 21, Ldc_I4_S = 31, Ldc_I8 = 33, Ldc_R4 = 34, Ldc_R8 = 35, Ldelema = 140, Ldelem_Any = 160, Ldelem_I = 148, Ldelem_I1 = 141, Ldelem_I2 = 143, Ldelem_I4 = 145, Ldelem_I8 = 147, Ldelem_R4 = 149, Ldelem_R8 = 150, Ldelem_Ref = 151, Ldelem_U1 = 142, Ldelem_U2 = 144, Ldelem_U4 = 146, Ldfld = 120, Ldflda = 121, Ldftn = 197, Ldind_I = 76, Ldind_I1 = 69, Ldind_I2 = 71, Ldind_I4 = 73, Ldind_I8 = 75, Ldind_R4 = 77, Ldind_R8 = 78, Ldind_Ref = 79, Ldind_U1 = 70, Ldind_U2 = 72, Ldind_U4 = 74, Ldlen = 139, Ldloc = 202, Ldloca = 203, Ldloca_S = 18, Ldloc_0 = 6, Ldloc_1 = 7, Ldloc_2 = 8, Ldloc_3 = 9, Ldloc_S = 17, Ldnull = 20, Ldobj = 112, Ldsfld = 123, Ldsflda = 124, Ldstr = 113, Ldtoken = 174, Ldvirtftn = 198, Leave = 187, Leave_S = 188, Localloc = 205, Mkrefany = 173, Mul = 89, Mul_Ovf = 182, Mul_Ovf_Un = 183, Neg = 100, Newarr = 138, Newobj = 114, No = 214, Nop = 0, Not = 101, Or = 95, Pop = 37, Readonly = 218, Refanytype = 217, Refanyval = 171, Rem = 92, Rem_Un = 93, Ret = 41, Rethrow = 215, Shl = 97, Shr = 98, Shr_Un = 99, Sizeof = 216, Starg = 201, Starg_S = 16, Stelem_Any = 161, Stelem_I = 152, Stelem_I1 = 153, Stelem_I2 = 154, Stelem_I4 = 155, Stelem_I8 = 156, Stelem_R4 = 157, Stelem_R8 = 158, Stelem_Ref = 159, Stfld = 122, Stind_I = 189, Stind_I1 = 81, Stind_I2 = 82, Stind_I4 = 83, Stind_I8 = 84, Stind_R4 = 85, Stind_R8 = 86, Stind_Ref = 80, Stloc = 204, Stloc_0 = 10, Stloc_1 = 11, Stloc_2 = 12, Stloc_3 = 13, Stloc_S = 19, Stobj = 126, Stsfld = 125, Sub = 88, Sub_Ovf = 184, Sub_Ovf_Un = 185, Switch = 68, Tail = 209, Throw = 119, Unaligned = 207, Unbox = 118, Unbox_Any = 162, Volatile = 208, Xor = 96, } public sealed partial class ConstantDebugInformation : Mono.Cecil.Cil.DebugInformation { public ConstantDebugInformation(string name, Mono.Cecil.TypeReference constant_type, object value) { } public Mono.Cecil.TypeReference ConstantType { get { throw null; } set { } } public string Name { get { throw null; } set { } } public object Value { get { throw null; } set { } } } public abstract partial class CustomDebugInformation : Mono.Cecil.Cil.DebugInformation { internal CustomDebugInformation() { } public System.Guid Identifier { get { throw null; } } public abstract Mono.Cecil.Cil.CustomDebugInformationKind Kind { get; } } public enum CustomDebugInformationKind { AsyncMethodBody = 4, Binary = 0, DefaultNamespace = 3, DynamicVariable = 2, EmbeddedSource = 5, SourceLink = 6, StateMachineScope = 1, } public abstract partial class DebugInformation : Mono.Cecil.Cil.ICustomDebugInformationProvider, Mono.Cecil.IMetadataTokenProvider { internal DebugInformation() { } public Mono.Collections.Generic.Collection CustomDebugInformations { get { throw null; } } public bool HasCustomDebugInformations { get { throw null; } } public Mono.Cecil.MetadataToken MetadataToken { get { throw null; } set { } } } public partial class DefaultSymbolReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider { public DefaultSymbolReaderProvider() { } public DefaultSymbolReaderProvider(bool throwIfNoSymbol) { } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public partial class DefaultSymbolWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider { public DefaultSymbolWriterProvider() { } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public sealed partial class Document : Mono.Cecil.Cil.DebugInformation { public Document(string url) { } public byte[] EmbeddedSource { get { throw null; } set { } } public byte[] Hash { get { throw null; } set { } } public Mono.Cecil.Cil.DocumentHashAlgorithm HashAlgorithm { get { throw null; } set { } } public System.Guid HashAlgorithmGuid { get { throw null; } set { } } public Mono.Cecil.Cil.DocumentLanguage Language { get { throw null; } set { } } public System.Guid LanguageGuid { get { throw null; } set { } } public Mono.Cecil.Cil.DocumentLanguageVendor LanguageVendor { get { throw null; } set { } } public System.Guid LanguageVendorGuid { get { throw null; } set { } } public Mono.Cecil.Cil.DocumentType Type { get { throw null; } set { } } public System.Guid TypeGuid { get { throw null; } set { } } public string Url { get { throw null; } set { } } } public enum DocumentHashAlgorithm { MD5 = 1, None = 0, SHA1 = 2, SHA256 = 3, } public enum DocumentLanguage { Basic = 4, C = 1, Cil = 8, Cobol = 6, Cpp = 2, CSharp = 3, FSharp = 12, Java = 5, JScript = 9, MCpp = 11, Other = 0, Pascal = 7, Smc = 10, } public enum DocumentLanguageVendor { Microsoft = 1, Other = 0, } public enum DocumentType { Other = 0, Text = 1, } public sealed partial class EmbeddedPortablePdbReader : Mono.Cecil.Cil.ISymbolReader, System.IDisposable { internal EmbeddedPortablePdbReader() { } public void Dispose() { } public Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider() { throw null; } public bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header) { throw null; } public Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method) { throw null; } } public sealed partial class EmbeddedPortablePdbReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider { public EmbeddedPortablePdbReaderProvider() { } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public sealed partial class EmbeddedPortablePdbWriter : Mono.Cecil.Cil.ISymbolWriter, System.IDisposable { internal EmbeddedPortablePdbWriter() { } public void Dispose() { } public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; } public Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider() { throw null; } public void Write(Mono.Cecil.Cil.MethodDebugInformation info) { } } public sealed partial class EmbeddedPortablePdbWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider { public EmbeddedPortablePdbWriterProvider() { } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public sealed partial class EmbeddedSourceDebugInformation : Mono.Cecil.Cil.CustomDebugInformation { public static System.Guid KindIdentifier; public EmbeddedSourceDebugInformation(byte[] content, bool compress) { } public bool Compress { get { throw null; } set { } } public byte[] Content { get { throw null; } set { } } public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } } } public sealed partial class ExceptionHandler { public ExceptionHandler(Mono.Cecil.Cil.ExceptionHandlerType handlerType) { } public Mono.Cecil.TypeReference CatchType { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction FilterStart { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction HandlerEnd { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction HandlerStart { get { throw null; } set { } } public Mono.Cecil.Cil.ExceptionHandlerType HandlerType { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction TryEnd { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction TryStart { get { throw null; } set { } } } public enum ExceptionHandlerType { Catch = 0, Fault = 4, Filter = 1, Finally = 2, } public enum FlowControl { Branch = 0, Break = 1, Call = 2, Cond_Branch = 3, Meta = 4, Next = 5, Phi = 6, Return = 7, Throw = 8, } public partial interface ICustomDebugInformationProvider : Mono.Cecil.IMetadataTokenProvider { Mono.Collections.Generic.Collection CustomDebugInformations { get; } bool HasCustomDebugInformations { get; } } public sealed partial class ILProcessor { internal ILProcessor() { } public Mono.Cecil.Cil.MethodBody Body { get { throw null; } } public void Append(Mono.Cecil.Cil.Instruction instruction) { } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, byte value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, double value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, int value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, long value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, sbyte value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, float value) { throw null; } public Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, string value) { throw null; } public void Emit(Mono.Cecil.Cil.OpCode opcode) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, byte value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, double value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, int value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, long value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, sbyte value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, float value) { } public void Emit(Mono.Cecil.Cil.OpCode opcode, string value) { } public void InsertAfter(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { } public void InsertAfter(int index, Mono.Cecil.Cil.Instruction instruction) { } public void InsertBefore(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { } public void Remove(Mono.Cecil.Cil.Instruction instruction) { } public void RemoveAt(int index) { } public void Replace(Mono.Cecil.Cil.Instruction target, Mono.Cecil.Cil.Instruction instruction) { } public void Replace(int index, Mono.Cecil.Cil.Instruction instruction) { } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct ImageDebugDirectory { public int AddressOfRawData; public int Characteristics; public short MajorVersion; public short MinorVersion; public int PointerToRawData; public const int Size = 28; public int SizeOfData; public int TimeDateStamp; public Mono.Cecil.Cil.ImageDebugType Type; } public sealed partial class ImageDebugHeader { public ImageDebugHeader() { } public ImageDebugHeader(Mono.Cecil.Cil.ImageDebugHeaderEntry entry) { } public ImageDebugHeader(Mono.Cecil.Cil.ImageDebugHeaderEntry[] entries) { } public Mono.Cecil.Cil.ImageDebugHeaderEntry[] Entries { get { throw null; } } public bool HasEntries { get { throw null; } } } public sealed partial class ImageDebugHeaderEntry { public ImageDebugHeaderEntry(Mono.Cecil.Cil.ImageDebugDirectory directory, byte[] data) { } public byte[] Data { get { throw null; } } public Mono.Cecil.Cil.ImageDebugDirectory Directory { get { throw null; } } } public enum ImageDebugType { CodeView = 2, Deterministic = 16, EmbeddedPortablePdb = 17, } public sealed partial class ImportDebugInformation : Mono.Cecil.Cil.DebugInformation { public ImportDebugInformation() { } public bool HasTargets { get { throw null; } } public Mono.Cecil.Cil.ImportDebugInformation Parent { get { throw null; } set { } } public Mono.Collections.Generic.Collection Targets { get { throw null; } } } public sealed partial class ImportTarget { public ImportTarget(Mono.Cecil.Cil.ImportTargetKind kind) { } public string Alias { get { throw null; } set { } } public Mono.Cecil.AssemblyNameReference AssemblyReference { get { throw null; } set { } } public Mono.Cecil.Cil.ImportTargetKind Kind { get { throw null; } set { } } public string Namespace { get { throw null; } set { } } public Mono.Cecil.TypeReference Type { get { throw null; } set { } } } public enum ImportTargetKind : byte { DefineAssemblyAlias = (byte)6, DefineNamespaceAlias = (byte)7, DefineNamespaceInAssemblyAlias = (byte)8, DefineTypeAlias = (byte)9, ImportAlias = (byte)5, ImportNamespace = (byte)1, ImportNamespaceInAssembly = (byte)2, ImportType = (byte)3, ImportXmlNamespaceWithAlias = (byte)4, } public sealed partial class Instruction { internal Instruction() { } public Mono.Cecil.Cil.Instruction Next { get { throw null; } set { } } public int Offset { get { throw null; } set { } } public Mono.Cecil.Cil.OpCode OpCode { get { throw null; } set { } } public object Operand { get { throw null; } set { } } public Mono.Cecil.Cil.Instruction Previous { get { throw null; } set { } } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.CallSite site) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction target) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.Instruction[] targets) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.Cil.VariableDefinition variable) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.FieldReference field) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.MethodReference method) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.ParameterDefinition parameter) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, Mono.Cecil.TypeReference type) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, byte value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, double value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, int value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, long value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, sbyte value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, float value) { throw null; } public static Mono.Cecil.Cil.Instruction Create(Mono.Cecil.Cil.OpCode opcode, string value) { throw null; } public int GetSize() { throw null; } public override string ToString() { throw null; } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct InstructionOffset { private object _dummy; private int _dummyPrimitive; public InstructionOffset(Mono.Cecil.Cil.Instruction instruction) { throw null; } public InstructionOffset(int offset) { throw null; } public bool IsEndOfMethod { get { throw null; } } public int Offset { get { throw null; } } } public partial interface ISymbolReader : System.IDisposable { Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider(); bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header); Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method); } public partial interface ISymbolReaderProvider { Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream); Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName); } public partial interface ISymbolWriter : System.IDisposable { Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader(); Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider(); void Write(Mono.Cecil.Cil.MethodDebugInformation info); } public partial interface ISymbolWriterProvider { Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream); Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName); } public sealed partial class MethodBody { public MethodBody(Mono.Cecil.MethodDefinition method) { } public int CodeSize { get { throw null; } } public Mono.Collections.Generic.Collection ExceptionHandlers { get { throw null; } } public bool HasExceptionHandlers { get { throw null; } } public bool HasVariables { get { throw null; } } public bool InitLocals { get { throw null; } set { } } public Mono.Collections.Generic.Collection Instructions { get { throw null; } } public Mono.Cecil.MetadataToken LocalVarToken { get { throw null; } set { } } public int MaxStackSize { get { throw null; } set { } } public Mono.Cecil.MethodDefinition Method { get { throw null; } } public Mono.Cecil.ParameterDefinition ThisParameter { get { throw null; } } public Mono.Collections.Generic.Collection Variables { get { throw null; } } public Mono.Cecil.Cil.ILProcessor GetILProcessor() { throw null; } } public sealed partial class MethodDebugInformation : Mono.Cecil.Cil.DebugInformation { internal MethodDebugInformation() { } public bool HasSequencePoints { get { throw null; } } public Mono.Cecil.MethodDefinition Method { get { throw null; } } public Mono.Cecil.Cil.ScopeDebugInformation Scope { get { throw null; } set { } } public Mono.Collections.Generic.Collection SequencePoints { get { throw null; } } public Mono.Cecil.MethodDefinition StateMachineKickOffMethod { get { throw null; } set { } } public System.Collections.Generic.IEnumerable GetScopes() { throw null; } public Mono.Cecil.Cil.SequencePoint GetSequencePoint(Mono.Cecil.Cil.Instruction instruction) { throw null; } public System.Collections.Generic.IDictionary GetSequencePointMapping() { throw null; } public bool TryGetName(Mono.Cecil.Cil.VariableDefinition variable, out string name) { throw null; } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct OpCode : System.IEquatable { private int _dummyPrimitive; public Mono.Cecil.Cil.Code Code { get { throw null; } } public Mono.Cecil.Cil.FlowControl FlowControl { get { throw null; } } public string Name { get { throw null; } } public byte Op1 { get { throw null; } } public byte Op2 { get { throw null; } } public Mono.Cecil.Cil.OpCodeType OpCodeType { get { throw null; } } public Mono.Cecil.Cil.OperandType OperandType { get { throw null; } } public int Size { get { throw null; } } public Mono.Cecil.Cil.StackBehaviour StackBehaviourPop { get { throw null; } } public Mono.Cecil.Cil.StackBehaviour StackBehaviourPush { get { throw null; } } public short Value { get { throw null; } } public bool Equals(Mono.Cecil.Cil.OpCode opcode) { throw null; } public override bool Equals(object obj) { throw null; } public override int GetHashCode() { throw null; } public static bool operator ==(Mono.Cecil.Cil.OpCode one, Mono.Cecil.Cil.OpCode other) { throw null; } public static bool operator !=(Mono.Cecil.Cil.OpCode one, Mono.Cecil.Cil.OpCode other) { throw null; } public override string ToString() { throw null; } } public static partial class OpCodes { public static readonly Mono.Cecil.Cil.OpCode Add; public static readonly Mono.Cecil.Cil.OpCode Add_Ovf; public static readonly Mono.Cecil.Cil.OpCode Add_Ovf_Un; public static readonly Mono.Cecil.Cil.OpCode And; public static readonly Mono.Cecil.Cil.OpCode Arglist; public static readonly Mono.Cecil.Cil.OpCode Beq; public static readonly Mono.Cecil.Cil.OpCode Beq_S; public static readonly Mono.Cecil.Cil.OpCode Bge; public static readonly Mono.Cecil.Cil.OpCode Bge_S; public static readonly Mono.Cecil.Cil.OpCode Bge_Un; public static readonly Mono.Cecil.Cil.OpCode Bge_Un_S; public static readonly Mono.Cecil.Cil.OpCode Bgt; public static readonly Mono.Cecil.Cil.OpCode Bgt_S; public static readonly Mono.Cecil.Cil.OpCode Bgt_Un; public static readonly Mono.Cecil.Cil.OpCode Bgt_Un_S; public static readonly Mono.Cecil.Cil.OpCode Ble; public static readonly Mono.Cecil.Cil.OpCode Ble_S; public static readonly Mono.Cecil.Cil.OpCode Ble_Un; public static readonly Mono.Cecil.Cil.OpCode Ble_Un_S; public static readonly Mono.Cecil.Cil.OpCode Blt; public static readonly Mono.Cecil.Cil.OpCode Blt_S; public static readonly Mono.Cecil.Cil.OpCode Blt_Un; public static readonly Mono.Cecil.Cil.OpCode Blt_Un_S; public static readonly Mono.Cecil.Cil.OpCode Bne_Un; public static readonly Mono.Cecil.Cil.OpCode Bne_Un_S; public static readonly Mono.Cecil.Cil.OpCode Box; public static readonly Mono.Cecil.Cil.OpCode Br; public static readonly Mono.Cecil.Cil.OpCode Break; public static readonly Mono.Cecil.Cil.OpCode Brfalse; public static readonly Mono.Cecil.Cil.OpCode Brfalse_S; public static readonly Mono.Cecil.Cil.OpCode Brtrue; public static readonly Mono.Cecil.Cil.OpCode Brtrue_S; public static readonly Mono.Cecil.Cil.OpCode Br_S; public static readonly Mono.Cecil.Cil.OpCode Call; public static readonly Mono.Cecil.Cil.OpCode Calli; public static readonly Mono.Cecil.Cil.OpCode Callvirt; public static readonly Mono.Cecil.Cil.OpCode Castclass; public static readonly Mono.Cecil.Cil.OpCode Ceq; public static readonly Mono.Cecil.Cil.OpCode Cgt; public static readonly Mono.Cecil.Cil.OpCode Cgt_Un; public static readonly Mono.Cecil.Cil.OpCode Ckfinite; public static readonly Mono.Cecil.Cil.OpCode Clt; public static readonly Mono.Cecil.Cil.OpCode Clt_Un; public static readonly Mono.Cecil.Cil.OpCode Constrained; public static readonly Mono.Cecil.Cil.OpCode Conv_I; public static readonly Mono.Cecil.Cil.OpCode Conv_I1; public static readonly Mono.Cecil.Cil.OpCode Conv_I2; public static readonly Mono.Cecil.Cil.OpCode Conv_I4; public static readonly Mono.Cecil.Cil.OpCode Conv_I8; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I1; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I1_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I2; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I2_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I4; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I4_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I8; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I8_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_I_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U1; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U1_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U2; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U2_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U4; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U4_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U8; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U8_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_Ovf_U_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_R4; public static readonly Mono.Cecil.Cil.OpCode Conv_R8; public static readonly Mono.Cecil.Cil.OpCode Conv_R_Un; public static readonly Mono.Cecil.Cil.OpCode Conv_U; public static readonly Mono.Cecil.Cil.OpCode Conv_U1; public static readonly Mono.Cecil.Cil.OpCode Conv_U2; public static readonly Mono.Cecil.Cil.OpCode Conv_U4; public static readonly Mono.Cecil.Cil.OpCode Conv_U8; public static readonly Mono.Cecil.Cil.OpCode Cpblk; public static readonly Mono.Cecil.Cil.OpCode Cpobj; public static readonly Mono.Cecil.Cil.OpCode Div; public static readonly Mono.Cecil.Cil.OpCode Div_Un; public static readonly Mono.Cecil.Cil.OpCode Dup; public static readonly Mono.Cecil.Cil.OpCode Endfilter; public static readonly Mono.Cecil.Cil.OpCode Endfinally; public static readonly Mono.Cecil.Cil.OpCode Initblk; public static readonly Mono.Cecil.Cil.OpCode Initobj; public static readonly Mono.Cecil.Cil.OpCode Isinst; public static readonly Mono.Cecil.Cil.OpCode Jmp; public static readonly Mono.Cecil.Cil.OpCode Ldarg; public static readonly Mono.Cecil.Cil.OpCode Ldarga; public static readonly Mono.Cecil.Cil.OpCode Ldarga_S; public static readonly Mono.Cecil.Cil.OpCode Ldarg_0; public static readonly Mono.Cecil.Cil.OpCode Ldarg_1; public static readonly Mono.Cecil.Cil.OpCode Ldarg_2; public static readonly Mono.Cecil.Cil.OpCode Ldarg_3; public static readonly Mono.Cecil.Cil.OpCode Ldarg_S; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_0; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_1; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_2; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_3; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_4; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_5; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_6; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_7; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_8; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_M1; public static readonly Mono.Cecil.Cil.OpCode Ldc_I4_S; public static readonly Mono.Cecil.Cil.OpCode Ldc_I8; public static readonly Mono.Cecil.Cil.OpCode Ldc_R4; public static readonly Mono.Cecil.Cil.OpCode Ldc_R8; public static readonly Mono.Cecil.Cil.OpCode Ldelema; public static readonly Mono.Cecil.Cil.OpCode Ldelem_Any; public static readonly Mono.Cecil.Cil.OpCode Ldelem_I; public static readonly Mono.Cecil.Cil.OpCode Ldelem_I1; public static readonly Mono.Cecil.Cil.OpCode Ldelem_I2; public static readonly Mono.Cecil.Cil.OpCode Ldelem_I4; public static readonly Mono.Cecil.Cil.OpCode Ldelem_I8; public static readonly Mono.Cecil.Cil.OpCode Ldelem_R4; public static readonly Mono.Cecil.Cil.OpCode Ldelem_R8; public static readonly Mono.Cecil.Cil.OpCode Ldelem_Ref; public static readonly Mono.Cecil.Cil.OpCode Ldelem_U1; public static readonly Mono.Cecil.Cil.OpCode Ldelem_U2; public static readonly Mono.Cecil.Cil.OpCode Ldelem_U4; public static readonly Mono.Cecil.Cil.OpCode Ldfld; public static readonly Mono.Cecil.Cil.OpCode Ldflda; public static readonly Mono.Cecil.Cil.OpCode Ldftn; public static readonly Mono.Cecil.Cil.OpCode Ldind_I; public static readonly Mono.Cecil.Cil.OpCode Ldind_I1; public static readonly Mono.Cecil.Cil.OpCode Ldind_I2; public static readonly Mono.Cecil.Cil.OpCode Ldind_I4; public static readonly Mono.Cecil.Cil.OpCode Ldind_I8; public static readonly Mono.Cecil.Cil.OpCode Ldind_R4; public static readonly Mono.Cecil.Cil.OpCode Ldind_R8; public static readonly Mono.Cecil.Cil.OpCode Ldind_Ref; public static readonly Mono.Cecil.Cil.OpCode Ldind_U1; public static readonly Mono.Cecil.Cil.OpCode Ldind_U2; public static readonly Mono.Cecil.Cil.OpCode Ldind_U4; public static readonly Mono.Cecil.Cil.OpCode Ldlen; public static readonly Mono.Cecil.Cil.OpCode Ldloc; public static readonly Mono.Cecil.Cil.OpCode Ldloca; public static readonly Mono.Cecil.Cil.OpCode Ldloca_S; public static readonly Mono.Cecil.Cil.OpCode Ldloc_0; public static readonly Mono.Cecil.Cil.OpCode Ldloc_1; public static readonly Mono.Cecil.Cil.OpCode Ldloc_2; public static readonly Mono.Cecil.Cil.OpCode Ldloc_3; public static readonly Mono.Cecil.Cil.OpCode Ldloc_S; public static readonly Mono.Cecil.Cil.OpCode Ldnull; public static readonly Mono.Cecil.Cil.OpCode Ldobj; public static readonly Mono.Cecil.Cil.OpCode Ldsfld; public static readonly Mono.Cecil.Cil.OpCode Ldsflda; public static readonly Mono.Cecil.Cil.OpCode Ldstr; public static readonly Mono.Cecil.Cil.OpCode Ldtoken; public static readonly Mono.Cecil.Cil.OpCode Ldvirtftn; public static readonly Mono.Cecil.Cil.OpCode Leave; public static readonly Mono.Cecil.Cil.OpCode Leave_S; public static readonly Mono.Cecil.Cil.OpCode Localloc; public static readonly Mono.Cecil.Cil.OpCode Mkrefany; public static readonly Mono.Cecil.Cil.OpCode Mul; public static readonly Mono.Cecil.Cil.OpCode Mul_Ovf; public static readonly Mono.Cecil.Cil.OpCode Mul_Ovf_Un; public static readonly Mono.Cecil.Cil.OpCode Neg; public static readonly Mono.Cecil.Cil.OpCode Newarr; public static readonly Mono.Cecil.Cil.OpCode Newobj; public static readonly Mono.Cecil.Cil.OpCode No; public static readonly Mono.Cecil.Cil.OpCode Nop; public static readonly Mono.Cecil.Cil.OpCode Not; public static readonly Mono.Cecil.Cil.OpCode Or; public static readonly Mono.Cecil.Cil.OpCode Pop; public static readonly Mono.Cecil.Cil.OpCode Readonly; public static readonly Mono.Cecil.Cil.OpCode Refanytype; public static readonly Mono.Cecil.Cil.OpCode Refanyval; public static readonly Mono.Cecil.Cil.OpCode Rem; public static readonly Mono.Cecil.Cil.OpCode Rem_Un; public static readonly Mono.Cecil.Cil.OpCode Ret; public static readonly Mono.Cecil.Cil.OpCode Rethrow; public static readonly Mono.Cecil.Cil.OpCode Shl; public static readonly Mono.Cecil.Cil.OpCode Shr; public static readonly Mono.Cecil.Cil.OpCode Shr_Un; public static readonly Mono.Cecil.Cil.OpCode Sizeof; public static readonly Mono.Cecil.Cil.OpCode Starg; public static readonly Mono.Cecil.Cil.OpCode Starg_S; public static readonly Mono.Cecil.Cil.OpCode Stelem_Any; public static readonly Mono.Cecil.Cil.OpCode Stelem_I; public static readonly Mono.Cecil.Cil.OpCode Stelem_I1; public static readonly Mono.Cecil.Cil.OpCode Stelem_I2; public static readonly Mono.Cecil.Cil.OpCode Stelem_I4; public static readonly Mono.Cecil.Cil.OpCode Stelem_I8; public static readonly Mono.Cecil.Cil.OpCode Stelem_R4; public static readonly Mono.Cecil.Cil.OpCode Stelem_R8; public static readonly Mono.Cecil.Cil.OpCode Stelem_Ref; public static readonly Mono.Cecil.Cil.OpCode Stfld; public static readonly Mono.Cecil.Cil.OpCode Stind_I; public static readonly Mono.Cecil.Cil.OpCode Stind_I1; public static readonly Mono.Cecil.Cil.OpCode Stind_I2; public static readonly Mono.Cecil.Cil.OpCode Stind_I4; public static readonly Mono.Cecil.Cil.OpCode Stind_I8; public static readonly Mono.Cecil.Cil.OpCode Stind_R4; public static readonly Mono.Cecil.Cil.OpCode Stind_R8; public static readonly Mono.Cecil.Cil.OpCode Stind_Ref; public static readonly Mono.Cecil.Cil.OpCode Stloc; public static readonly Mono.Cecil.Cil.OpCode Stloc_0; public static readonly Mono.Cecil.Cil.OpCode Stloc_1; public static readonly Mono.Cecil.Cil.OpCode Stloc_2; public static readonly Mono.Cecil.Cil.OpCode Stloc_3; public static readonly Mono.Cecil.Cil.OpCode Stloc_S; public static readonly Mono.Cecil.Cil.OpCode Stobj; public static readonly Mono.Cecil.Cil.OpCode Stsfld; public static readonly Mono.Cecil.Cil.OpCode Sub; public static readonly Mono.Cecil.Cil.OpCode Sub_Ovf; public static readonly Mono.Cecil.Cil.OpCode Sub_Ovf_Un; public static readonly Mono.Cecil.Cil.OpCode Switch; public static readonly Mono.Cecil.Cil.OpCode Tail; public static readonly Mono.Cecil.Cil.OpCode Throw; public static readonly Mono.Cecil.Cil.OpCode Unaligned; public static readonly Mono.Cecil.Cil.OpCode Unbox; public static readonly Mono.Cecil.Cil.OpCode Unbox_Any; public static readonly Mono.Cecil.Cil.OpCode Volatile; public static readonly Mono.Cecil.Cil.OpCode Xor; } public enum OpCodeType { Annotation = 0, Macro = 1, Nternal = 2, Objmodel = 3, Prefix = 4, Primitive = 5, } public enum OperandType { InlineArg = 14, InlineBrTarget = 0, InlineField = 1, InlineI = 2, InlineI8 = 3, InlineMethod = 4, InlineNone = 5, InlinePhi = 6, InlineR = 7, InlineSig = 8, InlineString = 9, InlineSwitch = 10, InlineTok = 11, InlineType = 12, InlineVar = 13, ShortInlineArg = 19, ShortInlineBrTarget = 15, ShortInlineI = 16, ShortInlineR = 17, ShortInlineVar = 18, } public sealed partial class PortablePdbReader : Mono.Cecil.Cil.ISymbolReader, System.IDisposable { internal PortablePdbReader() { } public void Dispose() { } public Mono.Cecil.Cil.ISymbolWriterProvider GetWriterProvider() { throw null; } public bool ProcessDebugHeader(Mono.Cecil.Cil.ImageDebugHeader header) { throw null; } public Mono.Cecil.Cil.MethodDebugInformation Read(Mono.Cecil.MethodDefinition method) { throw null; } } public sealed partial class PortablePdbReaderProvider : Mono.Cecil.Cil.ISymbolReaderProvider { public PortablePdbReaderProvider() { } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolReader GetSymbolReader(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public sealed partial class PortablePdbWriter : Mono.Cecil.Cil.ISymbolWriter, System.IDisposable { internal PortablePdbWriter() { } public void Dispose() { } public Mono.Cecil.Cil.ImageDebugHeader GetDebugHeader() { throw null; } public Mono.Cecil.Cil.ISymbolReaderProvider GetReaderProvider() { throw null; } public void Write(Mono.Cecil.Cil.MethodDebugInformation info) { } } public sealed partial class PortablePdbWriterProvider : Mono.Cecil.Cil.ISymbolWriterProvider { public PortablePdbWriterProvider() { } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, System.IO.Stream symbolStream) { throw null; } public Mono.Cecil.Cil.ISymbolWriter GetSymbolWriter(Mono.Cecil.ModuleDefinition module, string fileName) { throw null; } } public sealed partial class ScopeDebugInformation : Mono.Cecil.Cil.DebugInformation { public ScopeDebugInformation(Mono.Cecil.Cil.Instruction start, Mono.Cecil.Cil.Instruction end) { } public Mono.Collections.Generic.Collection Constants { get { throw null; } } public Mono.Cecil.Cil.InstructionOffset End { get { throw null; } set { } } public bool HasConstants { get { throw null; } } public bool HasScopes { get { throw null; } } public bool HasVariables { get { throw null; } } public Mono.Cecil.Cil.ImportDebugInformation Import { get { throw null; } set { } } public Mono.Collections.Generic.Collection Scopes { get { throw null; } } public Mono.Cecil.Cil.InstructionOffset Start { get { throw null; } set { } } public Mono.Collections.Generic.Collection Variables { get { throw null; } } public bool TryGetName(Mono.Cecil.Cil.VariableDefinition variable, out string name) { throw null; } } public sealed partial class SequencePoint { public SequencePoint(Mono.Cecil.Cil.Instruction instruction, Mono.Cecil.Cil.Document document) { } public Mono.Cecil.Cil.Document Document { get { throw null; } set { } } public int EndColumn { get { throw null; } set { } } public int EndLine { get { throw null; } set { } } public bool IsHidden { get { throw null; } } public int Offset { get { throw null; } } public int StartColumn { get { throw null; } set { } } public int StartLine { get { throw null; } set { } } } public sealed partial class SourceLinkDebugInformation : Mono.Cecil.Cil.CustomDebugInformation { public static System.Guid KindIdentifier; public SourceLinkDebugInformation(string content) { } public string Content { get { throw null; } set { } } public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } } } public enum StackBehaviour { Pop0 = 0, Pop1 = 1, Pop1_pop1 = 2, PopAll = 18, Popi = 3, Popi_pop1 = 4, Popi_popi = 5, Popi_popi8 = 6, Popi_popi_popi = 7, Popi_popr4 = 8, Popi_popr8 = 9, Popref = 10, Popref_pop1 = 11, Popref_popi = 12, Popref_popi_popi = 13, Popref_popi_popi8 = 14, Popref_popi_popr4 = 15, Popref_popi_popr8 = 16, Popref_popi_popref = 17, Push0 = 19, Push1 = 20, Push1_push1 = 21, Pushi = 22, Pushi8 = 23, Pushr4 = 24, Pushr8 = 25, Pushref = 26, Varpop = 27, Varpush = 28, } public sealed partial class StateMachineScope { public StateMachineScope(Mono.Cecil.Cil.Instruction start, Mono.Cecil.Cil.Instruction end) { } public Mono.Cecil.Cil.InstructionOffset End { get { throw null; } set { } } public Mono.Cecil.Cil.InstructionOffset Start { get { throw null; } set { } } } public sealed partial class StateMachineScopeDebugInformation : Mono.Cecil.Cil.CustomDebugInformation { public static System.Guid KindIdentifier; public StateMachineScopeDebugInformation() { } public override Mono.Cecil.Cil.CustomDebugInformationKind Kind { get { throw null; } } public Mono.Collections.Generic.Collection Scopes { get { throw null; } } } [System.SerializableAttribute] public sealed partial class SymbolsNotFoundException : System.IO.FileNotFoundException { public SymbolsNotFoundException(string message) { } } [System.SerializableAttribute] public sealed partial class SymbolsNotMatchingException : System.InvalidOperationException { public SymbolsNotMatchingException(string message) { } } [System.FlagsAttribute] public enum VariableAttributes : ushort { DebuggerHidden = (ushort)1, None = (ushort)0, } public sealed partial class VariableDebugInformation : Mono.Cecil.Cil.DebugInformation { public VariableDebugInformation(Mono.Cecil.Cil.VariableDefinition variable, string name) { } public Mono.Cecil.Cil.VariableAttributes Attributes { get { throw null; } set { } } public int Index { get { throw null; } } public bool IsDebuggerHidden { get { throw null; } set { } } public string Name { get { throw null; } set { } } } public sealed partial class VariableDefinition : Mono.Cecil.Cil.VariableReference { public VariableDefinition(Mono.Cecil.TypeReference variableType) { } public bool IsPinned { get { throw null; } } public override Mono.Cecil.Cil.VariableDefinition Resolve() { throw null; } } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct VariableIndex { private object _dummy; private int _dummyPrimitive; public VariableIndex(Mono.Cecil.Cil.VariableDefinition variable) { throw null; } public VariableIndex(int index) { throw null; } public int Index { get { throw null; } } } public abstract partial class VariableReference { internal VariableReference() { } protected Mono.Cecil.TypeReference variable_type; public int Index { get { throw null; } } public Mono.Cecil.TypeReference VariableType { get { throw null; } set { } } public abstract Mono.Cecil.Cil.VariableDefinition Resolve(); public override string ToString() { throw null; } } } namespace Mono.Collections.Generic { public partial class Collection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList { public Collection() { } public Collection(System.Collections.Generic.ICollection items) { } public Collection(int capacity) { } public int Capacity { get { throw null; } set { } } public int Count { get { throw null; } } public T this[int index] { get { throw null; } set { } } bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } int System.Collections.ICollection.Count { get { throw null; } } bool System.Collections.ICollection.IsSynchronized { get { throw null; } } object System.Collections.ICollection.SyncRoot { get { throw null; } } bool System.Collections.IList.IsFixedSize { get { throw null; } } bool System.Collections.IList.IsReadOnly { get { throw null; } } object System.Collections.IList.this[int index] { get { throw null; } set { } } public void Add(T item) { } public void Clear() { } public bool Contains(T item) { throw null; } public void CopyTo(T[] array, int arrayIndex) { } public Mono.Collections.Generic.Collection.Enumerator GetEnumerator() { throw null; } public int IndexOf(T item) { throw null; } public void Insert(int index, T item) { } protected virtual void OnAdd(T item, int index) { } protected virtual void OnClear() { } protected virtual void OnInsert(T item, int index) { } protected virtual void OnRemove(T item, int index) { } protected virtual void OnSet(T item, int index) { } public bool Remove(T item) { throw null; } public void RemoveAt(int index) { } protected void Resize(int new_size) { } System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } void System.Collections.ICollection.CopyTo(System.Array array, int index) { } System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } int System.Collections.IList.Add(object value) { throw null; } void System.Collections.IList.Clear() { } bool System.Collections.IList.Contains(object value) { throw null; } int System.Collections.IList.IndexOf(object value) { throw null; } void System.Collections.IList.Insert(int index, object value) { } void System.Collections.IList.Remove(object value) { } void System.Collections.IList.RemoveAt(int index) { } public T[] ToArray() { throw null; } [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)] public partial struct Enumerator : System.Collections.Generic.IEnumerator, System.Collections.IEnumerator, System.IDisposable { private T current; private object _dummy; private int _dummyPrimitive; public T Current { get { throw null; } } object System.Collections.IEnumerator.Current { get { throw null; } } public void Dispose() { } public bool MoveNext() { throw null; } public void Reset() { } } } public sealed partial class ReadOnlyCollection : Mono.Collections.Generic.Collection, System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList { public ReadOnlyCollection(Mono.Collections.Generic.Collection collection) { } public ReadOnlyCollection(T[] array) { } public static Mono.Collections.Generic.ReadOnlyCollection Empty { get { throw null; } } bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } bool System.Collections.IList.IsFixedSize { get { throw null; } } bool System.Collections.IList.IsReadOnly { get { throw null; } } protected override void OnAdd(T item, int index) { } protected override void OnClear() { } protected override void OnInsert(T item, int index) { } protected override void OnRemove(T item, int index) { } protected override void OnSet(T item, int index) { } } }