// Generated by Haxe 4.3.7

#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class StringLiteralKind : global::haxe.lang.Enum {
		
		protected StringLiteralKind(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.StringLiteralKind DoubleQuotes = new global::haxe.macro.StringLiteralKind_DoubleQuotes();
		
		public static readonly global::haxe.macro.StringLiteralKind SingleQuotes = new global::haxe.macro.StringLiteralKind_SingleQuotes();
		
		protected static readonly string[] __hx_constructs = new string[]{"DoubleQuotes", "SingleQuotes"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class StringLiteralKind_DoubleQuotes : global::haxe.macro.StringLiteralKind {
		
		public StringLiteralKind_DoubleQuotes() : base(0) {
		}
		
		
		public override string getTag() {
			return "DoubleQuotes";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class StringLiteralKind_SingleQuotes : global::haxe.macro.StringLiteralKind {
		
		public StringLiteralKind_SingleQuotes() : base(1) {
		}
		
		
		public override string getTag() {
			return "SingleQuotes";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class Constant : global::haxe.lang.Enum {
		
		protected Constant(int index) : base(index) {
		}
		
		
		public static global::haxe.macro.Constant CInt(string v, string s) {
			return new global::haxe.macro.Constant_CInt(v, s);
		}
		
		
		public static global::haxe.macro.Constant CFloat(string f, string s) {
			return new global::haxe.macro.Constant_CFloat(f, s);
		}
		
		
		public static global::haxe.macro.Constant CString(string s, global::haxe.macro.StringLiteralKind kind) {
			return new global::haxe.macro.Constant_CString(s, kind);
		}
		
		
		public static global::haxe.macro.Constant CIdent(string s) {
			return new global::haxe.macro.Constant_CIdent(s);
		}
		
		
		public static global::haxe.macro.Constant CRegexp(string r, string opt) {
			return new global::haxe.macro.Constant_CRegexp(r, opt);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"CInt", "CFloat", "CString", "CIdent", "CRegexp"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Constant_CInt : global::haxe.macro.Constant {
		
		public Constant_CInt(string v, string s) : base(0) {
			this.v = v;
			this.s = s;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.v, this.s});
		}
		
		
		public override string getTag() {
			return "CInt";
		}
		
		
		public override int GetHashCode() {
			return global::haxe.lang.Enum.paramsGetHashCode(0, new object[]{this.v, this.s});
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Constant_CInt en = ( other as global::haxe.macro.Constant_CInt );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.v) ), ((object) (en.v) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.s) ), ((object) (en.s) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("CInt", new object[]{this.v, this.s});
		}
		
		
		public readonly string v;
		
		public readonly string s;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Constant_CFloat : global::haxe.macro.Constant {
		
		public Constant_CFloat(string f, string s) : base(1) {
			this.f = f;
			this.s = s;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.f, this.s});
		}
		
		
		public override string getTag() {
			return "CFloat";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.f, this.s});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Constant_CFloat en = ( other as global::haxe.macro.Constant_CFloat );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.f) ), ((object) (en.f) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.s) ), ((object) (en.s) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("CFloat", new object[]{this.f, this.s});
		}
		
		
		public readonly string f;
		
		public readonly string s;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Constant_CString : global::haxe.macro.Constant {
		
		public Constant_CString(string s, global::haxe.macro.StringLiteralKind kind) : base(2) {
			this.s = s;
			this.kind = kind;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.s, this.kind});
		}
		
		
		public override string getTag() {
			return "CString";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.s, this.kind});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Constant_CString en = ( other as global::haxe.macro.Constant_CString );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.s) ), ((object) (en.s) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.kind) ), ((object) (en.kind) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("CString", new object[]{this.s, this.kind});
		}
		
		
		public readonly string s;
		
		public readonly global::haxe.macro.StringLiteralKind kind;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Constant_CIdent : global::haxe.macro.Constant {
		
		public Constant_CIdent(string s) : base(3) {
			this.s = s;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.s});
		}
		
		
		public override string getTag() {
			return "CIdent";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(3, new object[]{this.s});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Constant_CIdent en = ( other as global::haxe.macro.Constant_CIdent );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.s) ), ((object) (en.s) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("CIdent", new object[]{this.s});
		}
		
		
		public readonly string s;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Constant_CRegexp : global::haxe.macro.Constant {
		
		public Constant_CRegexp(string r, string opt) : base(4) {
			this.r = r;
			this.opt = opt;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.r, this.opt});
		}
		
		
		public override string getTag() {
			return "CRegexp";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(4, new object[]{this.r, this.opt});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Constant_CRegexp en = ( other as global::haxe.macro.Constant_CRegexp );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.r) ), ((object) (en.r) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.opt) ), ((object) (en.opt) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("CRegexp", new object[]{this.r, this.opt});
		}
		
		
		public readonly string r;
		
		public readonly string opt;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class Binop : global::haxe.lang.Enum {
		
		protected Binop(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.Binop OpAdd = new global::haxe.macro.Binop_OpAdd();
		
		public static readonly global::haxe.macro.Binop OpMult = new global::haxe.macro.Binop_OpMult();
		
		public static readonly global::haxe.macro.Binop OpDiv = new global::haxe.macro.Binop_OpDiv();
		
		public static readonly global::haxe.macro.Binop OpSub = new global::haxe.macro.Binop_OpSub();
		
		public static readonly global::haxe.macro.Binop OpAssign = new global::haxe.macro.Binop_OpAssign();
		
		public static readonly global::haxe.macro.Binop OpEq = new global::haxe.macro.Binop_OpEq();
		
		public static readonly global::haxe.macro.Binop OpNotEq = new global::haxe.macro.Binop_OpNotEq();
		
		public static readonly global::haxe.macro.Binop OpGt = new global::haxe.macro.Binop_OpGt();
		
		public static readonly global::haxe.macro.Binop OpGte = new global::haxe.macro.Binop_OpGte();
		
		public static readonly global::haxe.macro.Binop OpLt = new global::haxe.macro.Binop_OpLt();
		
		public static readonly global::haxe.macro.Binop OpLte = new global::haxe.macro.Binop_OpLte();
		
		public static readonly global::haxe.macro.Binop OpAnd = new global::haxe.macro.Binop_OpAnd();
		
		public static readonly global::haxe.macro.Binop OpOr = new global::haxe.macro.Binop_OpOr();
		
		public static readonly global::haxe.macro.Binop OpXor = new global::haxe.macro.Binop_OpXor();
		
		public static readonly global::haxe.macro.Binop OpBoolAnd = new global::haxe.macro.Binop_OpBoolAnd();
		
		public static readonly global::haxe.macro.Binop OpBoolOr = new global::haxe.macro.Binop_OpBoolOr();
		
		public static readonly global::haxe.macro.Binop OpShl = new global::haxe.macro.Binop_OpShl();
		
		public static readonly global::haxe.macro.Binop OpShr = new global::haxe.macro.Binop_OpShr();
		
		public static readonly global::haxe.macro.Binop OpUShr = new global::haxe.macro.Binop_OpUShr();
		
		public static readonly global::haxe.macro.Binop OpMod = new global::haxe.macro.Binop_OpMod();
		
		public static global::haxe.macro.Binop OpAssignOp(global::haxe.macro.Binop op) {
			return new global::haxe.macro.Binop_OpAssignOp(op);
		}
		
		
		public static readonly global::haxe.macro.Binop OpInterval = new global::haxe.macro.Binop_OpInterval();
		
		public static readonly global::haxe.macro.Binop OpArrow = new global::haxe.macro.Binop_OpArrow();
		
		public static readonly global::haxe.macro.Binop OpIn = new global::haxe.macro.Binop_OpIn();
		
		public static readonly global::haxe.macro.Binop OpNullCoal = new global::haxe.macro.Binop_OpNullCoal();
		
		protected static readonly string[] __hx_constructs = new string[]{"OpAdd", "OpMult", "OpDiv", "OpSub", "OpAssign", "OpEq", "OpNotEq", "OpGt", "OpGte", "OpLt", "OpLte", "OpAnd", "OpOr", "OpXor", "OpBoolAnd", "OpBoolOr", "OpShl", "OpShr", "OpUShr", "OpMod", "OpAssignOp", "OpInterval", "OpArrow", "OpIn", "OpNullCoal"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpAdd : global::haxe.macro.Binop {
		
		public Binop_OpAdd() : base(0) {
		}
		
		
		public override string getTag() {
			return "OpAdd";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpMult : global::haxe.macro.Binop {
		
		public Binop_OpMult() : base(1) {
		}
		
		
		public override string getTag() {
			return "OpMult";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpDiv : global::haxe.macro.Binop {
		
		public Binop_OpDiv() : base(2) {
		}
		
		
		public override string getTag() {
			return "OpDiv";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpSub : global::haxe.macro.Binop {
		
		public Binop_OpSub() : base(3) {
		}
		
		
		public override string getTag() {
			return "OpSub";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpAssign : global::haxe.macro.Binop {
		
		public Binop_OpAssign() : base(4) {
		}
		
		
		public override string getTag() {
			return "OpAssign";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpEq : global::haxe.macro.Binop {
		
		public Binop_OpEq() : base(5) {
		}
		
		
		public override string getTag() {
			return "OpEq";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpNotEq : global::haxe.macro.Binop {
		
		public Binop_OpNotEq() : base(6) {
		}
		
		
		public override string getTag() {
			return "OpNotEq";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpGt : global::haxe.macro.Binop {
		
		public Binop_OpGt() : base(7) {
		}
		
		
		public override string getTag() {
			return "OpGt";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpGte : global::haxe.macro.Binop {
		
		public Binop_OpGte() : base(8) {
		}
		
		
		public override string getTag() {
			return "OpGte";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpLt : global::haxe.macro.Binop {
		
		public Binop_OpLt() : base(9) {
		}
		
		
		public override string getTag() {
			return "OpLt";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpLte : global::haxe.macro.Binop {
		
		public Binop_OpLte() : base(10) {
		}
		
		
		public override string getTag() {
			return "OpLte";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpAnd : global::haxe.macro.Binop {
		
		public Binop_OpAnd() : base(11) {
		}
		
		
		public override string getTag() {
			return "OpAnd";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpOr : global::haxe.macro.Binop {
		
		public Binop_OpOr() : base(12) {
		}
		
		
		public override string getTag() {
			return "OpOr";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpXor : global::haxe.macro.Binop {
		
		public Binop_OpXor() : base(13) {
		}
		
		
		public override string getTag() {
			return "OpXor";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpBoolAnd : global::haxe.macro.Binop {
		
		public Binop_OpBoolAnd() : base(14) {
		}
		
		
		public override string getTag() {
			return "OpBoolAnd";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpBoolOr : global::haxe.macro.Binop {
		
		public Binop_OpBoolOr() : base(15) {
		}
		
		
		public override string getTag() {
			return "OpBoolOr";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpShl : global::haxe.macro.Binop {
		
		public Binop_OpShl() : base(16) {
		}
		
		
		public override string getTag() {
			return "OpShl";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpShr : global::haxe.macro.Binop {
		
		public Binop_OpShr() : base(17) {
		}
		
		
		public override string getTag() {
			return "OpShr";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpUShr : global::haxe.macro.Binop {
		
		public Binop_OpUShr() : base(18) {
		}
		
		
		public override string getTag() {
			return "OpUShr";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpMod : global::haxe.macro.Binop {
		
		public Binop_OpMod() : base(19) {
		}
		
		
		public override string getTag() {
			return "OpMod";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpAssignOp : global::haxe.macro.Binop {
		
		public Binop_OpAssignOp(global::haxe.macro.Binop op) : base(20) {
			this.op = op;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.op});
		}
		
		
		public override string getTag() {
			return "OpAssignOp";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(20, new object[]{this.op});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.Binop_OpAssignOp en = ( other as global::haxe.macro.Binop_OpAssignOp );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.op) ), ((object) (en.op) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("OpAssignOp", new object[]{this.op});
		}
		
		
		public readonly global::haxe.macro.Binop op;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpInterval : global::haxe.macro.Binop {
		
		public Binop_OpInterval() : base(21) {
		}
		
		
		public override string getTag() {
			return "OpInterval";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpArrow : global::haxe.macro.Binop {
		
		public Binop_OpArrow() : base(22) {
		}
		
		
		public override string getTag() {
			return "OpArrow";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpIn : global::haxe.macro.Binop {
		
		public Binop_OpIn() : base(23) {
		}
		
		
		public override string getTag() {
			return "OpIn";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Binop_OpNullCoal : global::haxe.macro.Binop {
		
		public Binop_OpNullCoal() : base(24) {
		}
		
		
		public override string getTag() {
			return "OpNullCoal";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class Unop : global::haxe.lang.Enum {
		
		protected Unop(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.Unop OpIncrement = new global::haxe.macro.Unop_OpIncrement();
		
		public static readonly global::haxe.macro.Unop OpDecrement = new global::haxe.macro.Unop_OpDecrement();
		
		public static readonly global::haxe.macro.Unop OpNot = new global::haxe.macro.Unop_OpNot();
		
		public static readonly global::haxe.macro.Unop OpNeg = new global::haxe.macro.Unop_OpNeg();
		
		public static readonly global::haxe.macro.Unop OpNegBits = new global::haxe.macro.Unop_OpNegBits();
		
		public static readonly global::haxe.macro.Unop OpSpread = new global::haxe.macro.Unop_OpSpread();
		
		protected static readonly string[] __hx_constructs = new string[]{"OpIncrement", "OpDecrement", "OpNot", "OpNeg", "OpNegBits", "OpSpread"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpIncrement : global::haxe.macro.Unop {
		
		public Unop_OpIncrement() : base(0) {
		}
		
		
		public override string getTag() {
			return "OpIncrement";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpDecrement : global::haxe.macro.Unop {
		
		public Unop_OpDecrement() : base(1) {
		}
		
		
		public override string getTag() {
			return "OpDecrement";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpNot : global::haxe.macro.Unop {
		
		public Unop_OpNot() : base(2) {
		}
		
		
		public override string getTag() {
			return "OpNot";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpNeg : global::haxe.macro.Unop {
		
		public Unop_OpNeg() : base(3) {
		}
		
		
		public override string getTag() {
			return "OpNeg";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpNegBits : global::haxe.macro.Unop {
		
		public Unop_OpNegBits() : base(4) {
		}
		
		
		public override string getTag() {
			return "OpNegBits";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Unop_OpSpread : global::haxe.macro.Unop {
		
		public Unop_OpSpread() : base(5) {
		}
		
		
		public override string getTag() {
			return "OpSpread";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class EFieldKind : global::haxe.lang.Enum {
		
		protected EFieldKind(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.EFieldKind Normal = new global::haxe.macro.EFieldKind_Normal();
		
		public static readonly global::haxe.macro.EFieldKind Safe = new global::haxe.macro.EFieldKind_Safe();
		
		protected static readonly string[] __hx_constructs = new string[]{"Normal", "Safe"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class EFieldKind_Normal : global::haxe.macro.EFieldKind {
		
		public EFieldKind_Normal() : base(0) {
		}
		
		
		public override string getTag() {
			return "Normal";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class EFieldKind_Safe : global::haxe.macro.EFieldKind {
		
		public EFieldKind_Safe() : base(1) {
		}
		
		
		public override string getTag() {
			return "Safe";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class QuoteStatus : global::haxe.lang.Enum {
		
		protected QuoteStatus(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.QuoteStatus Unquoted = new global::haxe.macro.QuoteStatus_Unquoted();
		
		public static readonly global::haxe.macro.QuoteStatus Quoted = new global::haxe.macro.QuoteStatus_Quoted();
		
		protected static readonly string[] __hx_constructs = new string[]{"Unquoted", "Quoted"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class QuoteStatus_Unquoted : global::haxe.macro.QuoteStatus {
		
		public QuoteStatus_Unquoted() : base(0) {
		}
		
		
		public override string getTag() {
			return "Unquoted";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class QuoteStatus_Quoted : global::haxe.macro.QuoteStatus {
		
		public QuoteStatus_Quoted() : base(1) {
		}
		
		
		public override string getTag() {
			return "Quoted";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class FunctionKind : global::haxe.lang.Enum {
		
		protected FunctionKind(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.FunctionKind FAnonymous = new global::haxe.macro.FunctionKind_FAnonymous();
		
		public static global::haxe.macro.FunctionKind FNamed(string name, global::haxe.lang.Null<bool> inlined) {
			return new global::haxe.macro.FunctionKind_FNamed(name, inlined);
		}
		
		
		public static readonly global::haxe.macro.FunctionKind FArrow = new global::haxe.macro.FunctionKind_FArrow();
		
		protected static readonly string[] __hx_constructs = new string[]{"FAnonymous", "FNamed", "FArrow"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FunctionKind_FAnonymous : global::haxe.macro.FunctionKind {
		
		public FunctionKind_FAnonymous() : base(0) {
		}
		
		
		public override string getTag() {
			return "FAnonymous";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FunctionKind_FNamed : global::haxe.macro.FunctionKind {
		
		public FunctionKind_FNamed(string name, global::haxe.lang.Null<bool> inlined) : base(1) {
			this.name = name;
			this.inlined = inlined;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.name, (this.inlined).toDynamic()});
		}
		
		
		public override string getTag() {
			return "FNamed";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.name, (this.inlined).toDynamic()});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.FunctionKind_FNamed en = ( other as global::haxe.macro.FunctionKind_FNamed );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.name) ), ((object) (en.name) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>((this.inlined).toDynamic(), (en.inlined).toDynamic())) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("FNamed", new object[]{this.name, (this.inlined).toDynamic()});
		}
		
		
		public readonly string name;
		
		public readonly global::haxe.lang.Null<bool> inlined;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FunctionKind_FArrow : global::haxe.macro.FunctionKind {
		
		public FunctionKind_FArrow() : base(2) {
		}
		
		
		public override string getTag() {
			return "FArrow";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class ExprDef : global::haxe.lang.Enum {
		
		protected ExprDef(int index) : base(index) {
		}
		
		
		public static global::haxe.macro.ExprDef EConst(global::haxe.macro.Constant c) {
			return new global::haxe.macro.ExprDef_EConst(c);
		}
		
		
		public static global::haxe.macro.ExprDef EArray(object e1, object e2) {
			return new global::haxe.macro.ExprDef_EArray(e1, e2);
		}
		
		
		public static global::haxe.macro.ExprDef EBinop(global::haxe.macro.Binop op, object e1, object e2) {
			return new global::haxe.macro.ExprDef_EBinop(op, e1, e2);
		}
		
		
		public static global::haxe.macro.ExprDef EField(object e, string field, global::haxe.macro.EFieldKind kind) {
			return new global::haxe.macro.ExprDef_EField(e, field, kind);
		}
		
		
		public static global::haxe.macro.ExprDef EParenthesis(object e) {
			return new global::haxe.macro.ExprDef_EParenthesis(e);
		}
		
		
		public static global::haxe.macro.ExprDef EObjectDecl(global::Array<object> fields) {
			return new global::haxe.macro.ExprDef_EObjectDecl(fields);
		}
		
		
		public static global::haxe.macro.ExprDef EArrayDecl(global::Array<object> values) {
			return new global::haxe.macro.ExprDef_EArrayDecl(values);
		}
		
		
		public static global::haxe.macro.ExprDef ECall(object e, global::Array<object> @params) {
			return new global::haxe.macro.ExprDef_ECall(e, @params);
		}
		
		
		public static global::haxe.macro.ExprDef ENew(object t, global::Array<object> @params) {
			return new global::haxe.macro.ExprDef_ENew(t, @params);
		}
		
		
		public static global::haxe.macro.ExprDef EUnop(global::haxe.macro.Unop op, bool postFix, object e) {
			return new global::haxe.macro.ExprDef_EUnop(op, postFix, e);
		}
		
		
		public static global::haxe.macro.ExprDef EVars(global::Array<object> vars) {
			return new global::haxe.macro.ExprDef_EVars(vars);
		}
		
		
		public static global::haxe.macro.ExprDef EFunction(global::haxe.macro.FunctionKind kind, object f) {
			return new global::haxe.macro.ExprDef_EFunction(kind, f);
		}
		
		
		public static global::haxe.macro.ExprDef EBlock(global::Array<object> exprs) {
			return new global::haxe.macro.ExprDef_EBlock(exprs);
		}
		
		
		public static global::haxe.macro.ExprDef EFor(object it, object expr) {
			return new global::haxe.macro.ExprDef_EFor(it, expr);
		}
		
		
		public static global::haxe.macro.ExprDef EIf(object econd, object eif, object eelse) {
			return new global::haxe.macro.ExprDef_EIf(econd, eif, eelse);
		}
		
		
		public static global::haxe.macro.ExprDef EWhile(object econd, object e, bool normalWhile) {
			return new global::haxe.macro.ExprDef_EWhile(econd, e, normalWhile);
		}
		
		
		public static global::haxe.macro.ExprDef ESwitch(object e, global::Array<object> cases, object edef) {
			return new global::haxe.macro.ExprDef_ESwitch(e, cases, edef);
		}
		
		
		public static global::haxe.macro.ExprDef ETry(object e, global::Array<object> catches) {
			return new global::haxe.macro.ExprDef_ETry(e, catches);
		}
		
		
		public static global::haxe.macro.ExprDef EReturn(object e) {
			return new global::haxe.macro.ExprDef_EReturn(e);
		}
		
		
		public static readonly global::haxe.macro.ExprDef EBreak = new global::haxe.macro.ExprDef_EBreak();
		
		public static readonly global::haxe.macro.ExprDef EContinue = new global::haxe.macro.ExprDef_EContinue();
		
		public static global::haxe.macro.ExprDef EUntyped(object e) {
			return new global::haxe.macro.ExprDef_EUntyped(e);
		}
		
		
		public static global::haxe.macro.ExprDef EThrow(object e) {
			return new global::haxe.macro.ExprDef_EThrow(e);
		}
		
		
		public static global::haxe.macro.ExprDef ECast(object e, global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ExprDef_ECast(e, t);
		}
		
		
		public static global::haxe.macro.ExprDef EDisplay(object e, global::haxe.macro.DisplayKind displayKind) {
			return new global::haxe.macro.ExprDef_EDisplay(e, displayKind);
		}
		
		
		public static global::haxe.macro.ExprDef ETernary(object econd, object eif, object eelse) {
			return new global::haxe.macro.ExprDef_ETernary(econd, eif, eelse);
		}
		
		
		public static global::haxe.macro.ExprDef ECheckType(object e, global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ExprDef_ECheckType(e, t);
		}
		
		
		public static global::haxe.macro.ExprDef EMeta(object s, object e) {
			return new global::haxe.macro.ExprDef_EMeta(s, e);
		}
		
		
		public static global::haxe.macro.ExprDef EIs(object e, global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ExprDef_EIs(e, t);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"EConst", "EArray", "EBinop", "EField", "EParenthesis", "EObjectDecl", "EArrayDecl", "ECall", "ENew", "EUnop", "EVars", "EFunction", "EBlock", "EFor", "EIf", "EWhile", "ESwitch", "ETry", "EReturn", "EBreak", "EContinue", "EUntyped", "EThrow", "ECast", "EDisplay", "ETernary", "ECheckType", "EMeta", "EIs"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EConst : global::haxe.macro.ExprDef {
		
		public ExprDef_EConst(global::haxe.macro.Constant c) : base(0) {
			this.c = c;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.c});
		}
		
		
		public override string getTag() {
			return "EConst";
		}
		
		
		public override int GetHashCode() {
			return global::haxe.lang.Enum.paramsGetHashCode(0, new object[]{this.c});
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EConst en = ( other as global::haxe.macro.ExprDef_EConst );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.c) ), ((object) (en.c) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EConst", new object[]{this.c});
		}
		
		
		public readonly global::haxe.macro.Constant c;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EArray : global::haxe.macro.ExprDef {
		
		public ExprDef_EArray(object e1, object e2) : base(1) {
			this.e1 = e1;
			this.e2 = e2;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e1, this.e2});
		}
		
		
		public override string getTag() {
			return "EArray";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.e1, this.e2});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EArray en = ( other as global::haxe.macro.ExprDef_EArray );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e1) ), ((object) (en.e1) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e2) ), ((object) (en.e2) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EArray", new object[]{this.e1, this.e2});
		}
		
		
		public readonly object e1;
		
		public readonly object e2;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EBinop : global::haxe.macro.ExprDef {
		
		public ExprDef_EBinop(global::haxe.macro.Binop op, object e1, object e2) : base(2) {
			this.op = op;
			this.e1 = e1;
			this.e2 = e2;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.op, this.e1, this.e2});
		}
		
		
		public override string getTag() {
			return "EBinop";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.op, this.e1, this.e2});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EBinop en = ( other as global::haxe.macro.ExprDef_EBinop );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.op) ), ((object) (en.op) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e1) ), ((object) (en.e1) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e2) ), ((object) (en.e2) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EBinop", new object[]{this.op, this.e1, this.e2});
		}
		
		
		public readonly global::haxe.macro.Binop op;
		
		public readonly object e1;
		
		public readonly object e2;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EField : global::haxe.macro.ExprDef {
		
		public ExprDef_EField(object e, string field, global::haxe.macro.EFieldKind kind) : base(3) {
			this.e = e;
			this.field = field;
			this.kind = kind;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.field, this.kind});
		}
		
		
		public override string getTag() {
			return "EField";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(3, new object[]{this.e, this.field, this.kind});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EField en = ( other as global::haxe.macro.ExprDef_EField );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.field) ), ((object) (en.field) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.kind) ), ((object) (en.kind) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EField", new object[]{this.e, this.field, this.kind});
		}
		
		
		public readonly object e;
		
		public readonly string field;
		
		public readonly global::haxe.macro.EFieldKind kind;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EParenthesis : global::haxe.macro.ExprDef {
		
		public ExprDef_EParenthesis(object e) : base(4) {
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e});
		}
		
		
		public override string getTag() {
			return "EParenthesis";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(4, new object[]{this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EParenthesis en = ( other as global::haxe.macro.ExprDef_EParenthesis );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EParenthesis", new object[]{this.e});
		}
		
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EObjectDecl : global::haxe.macro.ExprDef {
		
		public ExprDef_EObjectDecl(global::Array<object> fields) : base(5) {
			this.fields = fields;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.fields});
		}
		
		
		public override string getTag() {
			return "EObjectDecl";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(5, new object[]{this.fields});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EObjectDecl en = ( other as global::haxe.macro.ExprDef_EObjectDecl );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.fields) ), ((object) (en.fields) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EObjectDecl", new object[]{this.fields});
		}
		
		
		public readonly global::Array<object> fields;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EArrayDecl : global::haxe.macro.ExprDef {
		
		public ExprDef_EArrayDecl(global::Array<object> values) : base(6) {
			this.values = values;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.values});
		}
		
		
		public override string getTag() {
			return "EArrayDecl";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(6, new object[]{this.values});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EArrayDecl en = ( other as global::haxe.macro.ExprDef_EArrayDecl );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.values) ), ((object) (en.values) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EArrayDecl", new object[]{this.values});
		}
		
		
		public readonly global::Array<object> values;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ECall : global::haxe.macro.ExprDef {
		
		public ExprDef_ECall(object e, global::Array<object> @params) : base(7) {
			this.e = e;
			this.@params = @params;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.@params});
		}
		
		
		public override string getTag() {
			return "ECall";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(7, new object[]{this.e, this.@params});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ECall en = ( other as global::haxe.macro.ExprDef_ECall );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.@params) ), ((object) (en.@params) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ECall", new object[]{this.e, this.@params});
		}
		
		
		public readonly object e;
		
		public readonly global::Array<object> @params;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ENew : global::haxe.macro.ExprDef {
		
		public ExprDef_ENew(object t, global::Array<object> @params) : base(8) {
			this.t = t;
			this.@params = @params;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t, this.@params});
		}
		
		
		public override string getTag() {
			return "ENew";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(8, new object[]{this.t, this.@params});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ENew en = ( other as global::haxe.macro.ExprDef_ENew );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.@params) ), ((object) (en.@params) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ENew", new object[]{this.t, this.@params});
		}
		
		
		public readonly object t;
		
		public readonly global::Array<object> @params;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EUnop : global::haxe.macro.ExprDef {
		
		public ExprDef_EUnop(global::haxe.macro.Unop op, bool postFix, object e) : base(9) {
			this.op = op;
			this.postFix = postFix;
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.op, this.postFix, this.e});
		}
		
		
		public override string getTag() {
			return "EUnop";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(9, new object[]{this.op, this.postFix, this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EUnop en = ( other as global::haxe.macro.ExprDef_EUnop );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.op) ), ((object) (en.op) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.postFix) ), ((object) (en.postFix) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EUnop", new object[]{this.op, this.postFix, this.e});
		}
		
		
		public readonly global::haxe.macro.Unop op;
		
		public readonly bool postFix;
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EVars : global::haxe.macro.ExprDef {
		
		public ExprDef_EVars(global::Array<object> vars) : base(10) {
			this.vars = vars;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.vars});
		}
		
		
		public override string getTag() {
			return "EVars";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(10, new object[]{this.vars});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EVars en = ( other as global::haxe.macro.ExprDef_EVars );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.vars) ), ((object) (en.vars) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EVars", new object[]{this.vars});
		}
		
		
		public readonly global::Array<object> vars;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EFunction : global::haxe.macro.ExprDef {
		
		public ExprDef_EFunction(global::haxe.macro.FunctionKind kind, object f) : base(11) {
			this.kind = kind;
			this.f = f;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.kind, this.f});
		}
		
		
		public override string getTag() {
			return "EFunction";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(11, new object[]{this.kind, this.f});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EFunction en = ( other as global::haxe.macro.ExprDef_EFunction );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.kind) ), ((object) (en.kind) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.f) ), ((object) (en.f) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EFunction", new object[]{this.kind, this.f});
		}
		
		
		public readonly global::haxe.macro.FunctionKind kind;
		
		public readonly object f;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EBlock : global::haxe.macro.ExprDef {
		
		public ExprDef_EBlock(global::Array<object> exprs) : base(12) {
			this.exprs = exprs;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.exprs});
		}
		
		
		public override string getTag() {
			return "EBlock";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(12, new object[]{this.exprs});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EBlock en = ( other as global::haxe.macro.ExprDef_EBlock );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.exprs) ), ((object) (en.exprs) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EBlock", new object[]{this.exprs});
		}
		
		
		public readonly global::Array<object> exprs;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EFor : global::haxe.macro.ExprDef {
		
		public ExprDef_EFor(object it, object expr) : base(13) {
			this.it = it;
			this.expr = expr;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.it, this.expr});
		}
		
		
		public override string getTag() {
			return "EFor";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(13, new object[]{this.it, this.expr});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EFor en = ( other as global::haxe.macro.ExprDef_EFor );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.it) ), ((object) (en.it) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.expr) ), ((object) (en.expr) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EFor", new object[]{this.it, this.expr});
		}
		
		
		public readonly object it;
		
		public readonly object expr;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EIf : global::haxe.macro.ExprDef {
		
		public ExprDef_EIf(object econd, object eif, object eelse) : base(14) {
			this.econd = econd;
			this.eif = eif;
			this.eelse = eelse;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.econd, this.eif, this.eelse});
		}
		
		
		public override string getTag() {
			return "EIf";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(14, new object[]{this.econd, this.eif, this.eelse});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EIf en = ( other as global::haxe.macro.ExprDef_EIf );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.econd) ), ((object) (en.econd) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.eif) ), ((object) (en.eif) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.eelse) ), ((object) (en.eelse) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EIf", new object[]{this.econd, this.eif, this.eelse});
		}
		
		
		public readonly object econd;
		
		public readonly object eif;
		
		public readonly object eelse;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EWhile : global::haxe.macro.ExprDef {
		
		public ExprDef_EWhile(object econd, object e, bool normalWhile) : base(15) {
			this.econd = econd;
			this.e = e;
			this.normalWhile = normalWhile;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.econd, this.e, this.normalWhile});
		}
		
		
		public override string getTag() {
			return "EWhile";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(15, new object[]{this.econd, this.e, this.normalWhile});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EWhile en = ( other as global::haxe.macro.ExprDef_EWhile );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.econd) ), ((object) (en.econd) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.normalWhile) ), ((object) (en.normalWhile) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EWhile", new object[]{this.econd, this.e, this.normalWhile});
		}
		
		
		public readonly object econd;
		
		public readonly object e;
		
		public readonly bool normalWhile;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ESwitch : global::haxe.macro.ExprDef {
		
		public ExprDef_ESwitch(object e, global::Array<object> cases, object edef) : base(16) {
			this.e = e;
			this.cases = cases;
			this.edef = edef;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.cases, this.edef});
		}
		
		
		public override string getTag() {
			return "ESwitch";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(16, new object[]{this.e, this.cases, this.edef});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ESwitch en = ( other as global::haxe.macro.ExprDef_ESwitch );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.cases) ), ((object) (en.cases) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.edef) ), ((object) (en.edef) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ESwitch", new object[]{this.e, this.cases, this.edef});
		}
		
		
		public readonly object e;
		
		public readonly global::Array<object> cases;
		
		public readonly object edef;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ETry : global::haxe.macro.ExprDef {
		
		public ExprDef_ETry(object e, global::Array<object> catches) : base(17) {
			this.e = e;
			this.catches = catches;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.catches});
		}
		
		
		public override string getTag() {
			return "ETry";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(17, new object[]{this.e, this.catches});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ETry en = ( other as global::haxe.macro.ExprDef_ETry );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.catches) ), ((object) (en.catches) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ETry", new object[]{this.e, this.catches});
		}
		
		
		public readonly object e;
		
		public readonly global::Array<object> catches;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EReturn : global::haxe.macro.ExprDef {
		
		public ExprDef_EReturn(object e) : base(18) {
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e});
		}
		
		
		public override string getTag() {
			return "EReturn";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(18, new object[]{this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EReturn en = ( other as global::haxe.macro.ExprDef_EReturn );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EReturn", new object[]{this.e});
		}
		
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EBreak : global::haxe.macro.ExprDef {
		
		public ExprDef_EBreak() : base(19) {
		}
		
		
		public override string getTag() {
			return "EBreak";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EContinue : global::haxe.macro.ExprDef {
		
		public ExprDef_EContinue() : base(20) {
		}
		
		
		public override string getTag() {
			return "EContinue";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EUntyped : global::haxe.macro.ExprDef {
		
		public ExprDef_EUntyped(object e) : base(21) {
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e});
		}
		
		
		public override string getTag() {
			return "EUntyped";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(21, new object[]{this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EUntyped en = ( other as global::haxe.macro.ExprDef_EUntyped );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EUntyped", new object[]{this.e});
		}
		
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EThrow : global::haxe.macro.ExprDef {
		
		public ExprDef_EThrow(object e) : base(22) {
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e});
		}
		
		
		public override string getTag() {
			return "EThrow";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(22, new object[]{this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EThrow en = ( other as global::haxe.macro.ExprDef_EThrow );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EThrow", new object[]{this.e});
		}
		
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ECast : global::haxe.macro.ExprDef {
		
		public ExprDef_ECast(object e, global::haxe.macro.ComplexType t) : base(23) {
			this.e = e;
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.t});
		}
		
		
		public override string getTag() {
			return "ECast";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(23, new object[]{this.e, this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ECast en = ( other as global::haxe.macro.ExprDef_ECast );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ECast", new object[]{this.e, this.t});
		}
		
		
		public readonly object e;
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EDisplay : global::haxe.macro.ExprDef {
		
		public ExprDef_EDisplay(object e, global::haxe.macro.DisplayKind displayKind) : base(24) {
			this.e = e;
			this.displayKind = displayKind;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.displayKind});
		}
		
		
		public override string getTag() {
			return "EDisplay";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(24, new object[]{this.e, this.displayKind});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EDisplay en = ( other as global::haxe.macro.ExprDef_EDisplay );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.displayKind) ), ((object) (en.displayKind) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EDisplay", new object[]{this.e, this.displayKind});
		}
		
		
		public readonly object e;
		
		public readonly global::haxe.macro.DisplayKind displayKind;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ETernary : global::haxe.macro.ExprDef {
		
		public ExprDef_ETernary(object econd, object eif, object eelse) : base(25) {
			this.econd = econd;
			this.eif = eif;
			this.eelse = eelse;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.econd, this.eif, this.eelse});
		}
		
		
		public override string getTag() {
			return "ETernary";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(25, new object[]{this.econd, this.eif, this.eelse});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ETernary en = ( other as global::haxe.macro.ExprDef_ETernary );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.econd) ), ((object) (en.econd) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.eif) ), ((object) (en.eif) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.eelse) ), ((object) (en.eelse) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ETernary", new object[]{this.econd, this.eif, this.eelse});
		}
		
		
		public readonly object econd;
		
		public readonly object eif;
		
		public readonly object eelse;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_ECheckType : global::haxe.macro.ExprDef {
		
		public ExprDef_ECheckType(object e, global::haxe.macro.ComplexType t) : base(26) {
			this.e = e;
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.t});
		}
		
		
		public override string getTag() {
			return "ECheckType";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(26, new object[]{this.e, this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_ECheckType en = ( other as global::haxe.macro.ExprDef_ECheckType );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("ECheckType", new object[]{this.e, this.t});
		}
		
		
		public readonly object e;
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EMeta : global::haxe.macro.ExprDef {
		
		public ExprDef_EMeta(object s, object e) : base(27) {
			this.s = s;
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.s, this.e});
		}
		
		
		public override string getTag() {
			return "EMeta";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(27, new object[]{this.s, this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EMeta en = ( other as global::haxe.macro.ExprDef_EMeta );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.s) ), ((object) (en.s) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EMeta", new object[]{this.s, this.e});
		}
		
		
		public readonly object s;
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ExprDef_EIs : global::haxe.macro.ExprDef {
		
		public ExprDef_EIs(object e, global::haxe.macro.ComplexType t) : base(28) {
			this.e = e;
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e, this.t});
		}
		
		
		public override string getTag() {
			return "EIs";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(28, new object[]{this.e, this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ExprDef_EIs en = ( other as global::haxe.macro.ExprDef_EIs );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("EIs", new object[]{this.e, this.t});
		}
		
		
		public readonly object e;
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class DisplayKind : global::haxe.lang.Enum {
		
		protected DisplayKind(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.DisplayKind DKCall = new global::haxe.macro.DisplayKind_DKCall();
		
		public static readonly global::haxe.macro.DisplayKind DKDot = new global::haxe.macro.DisplayKind_DKDot();
		
		public static readonly global::haxe.macro.DisplayKind DKStructure = new global::haxe.macro.DisplayKind_DKStructure();
		
		public static readonly global::haxe.macro.DisplayKind DKMarked = new global::haxe.macro.DisplayKind_DKMarked();
		
		public static global::haxe.macro.DisplayKind DKPattern(bool outermost) {
			return new global::haxe.macro.DisplayKind_DKPattern(outermost);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"DKCall", "DKDot", "DKStructure", "DKMarked", "DKPattern"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class DisplayKind_DKCall : global::haxe.macro.DisplayKind {
		
		public DisplayKind_DKCall() : base(0) {
		}
		
		
		public override string getTag() {
			return "DKCall";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class DisplayKind_DKDot : global::haxe.macro.DisplayKind {
		
		public DisplayKind_DKDot() : base(1) {
		}
		
		
		public override string getTag() {
			return "DKDot";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class DisplayKind_DKStructure : global::haxe.macro.DisplayKind {
		
		public DisplayKind_DKStructure() : base(2) {
		}
		
		
		public override string getTag() {
			return "DKStructure";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class DisplayKind_DKMarked : global::haxe.macro.DisplayKind {
		
		public DisplayKind_DKMarked() : base(3) {
		}
		
		
		public override string getTag() {
			return "DKMarked";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class DisplayKind_DKPattern : global::haxe.macro.DisplayKind {
		
		public DisplayKind_DKPattern(bool outermost) : base(4) {
			this.outermost = outermost;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.outermost});
		}
		
		
		public override string getTag() {
			return "DKPattern";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(4, new object[]{this.outermost});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.DisplayKind_DKPattern en = ( other as global::haxe.macro.DisplayKind_DKPattern );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.outermost) ), ((object) (en.outermost) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("DKPattern", new object[]{this.outermost});
		}
		
		
		public readonly bool outermost;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class ComplexType : global::haxe.lang.Enum {
		
		protected ComplexType(int index) : base(index) {
		}
		
		
		public static global::haxe.macro.ComplexType TPath(object p) {
			return new global::haxe.macro.ComplexType_TPath(p);
		}
		
		
		public static global::haxe.macro.ComplexType TFunction(global::Array<object> args, global::haxe.macro.ComplexType ret) {
			return new global::haxe.macro.ComplexType_TFunction(args, ret);
		}
		
		
		public static global::haxe.macro.ComplexType TAnonymous(global::Array<object> fields) {
			return new global::haxe.macro.ComplexType_TAnonymous(fields);
		}
		
		
		public static global::haxe.macro.ComplexType TParent(global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ComplexType_TParent(t);
		}
		
		
		public static global::haxe.macro.ComplexType TExtend(global::Array<object> p, global::Array<object> fields) {
			return new global::haxe.macro.ComplexType_TExtend(p, fields);
		}
		
		
		public static global::haxe.macro.ComplexType TOptional(global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ComplexType_TOptional(t);
		}
		
		
		public static global::haxe.macro.ComplexType TNamed(string n, global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.ComplexType_TNamed(n, t);
		}
		
		
		public static global::haxe.macro.ComplexType TIntersection(global::Array<object> tl) {
			return new global::haxe.macro.ComplexType_TIntersection(tl);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"TPath", "TFunction", "TAnonymous", "TParent", "TExtend", "TOptional", "TNamed", "TIntersection"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TPath : global::haxe.macro.ComplexType {
		
		public ComplexType_TPath(object p) : base(0) {
			this.p = p;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.p});
		}
		
		
		public override string getTag() {
			return "TPath";
		}
		
		
		public override int GetHashCode() {
			return global::haxe.lang.Enum.paramsGetHashCode(0, new object[]{this.p});
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TPath en = ( other as global::haxe.macro.ComplexType_TPath );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.p) ), ((object) (en.p) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TPath", new object[]{this.p});
		}
		
		
		public readonly object p;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TFunction : global::haxe.macro.ComplexType {
		
		public ComplexType_TFunction(global::Array<object> args, global::haxe.macro.ComplexType ret) : base(1) {
			this.args = args;
			this.ret = ret;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.args, this.ret});
		}
		
		
		public override string getTag() {
			return "TFunction";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.args, this.ret});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TFunction en = ( other as global::haxe.macro.ComplexType_TFunction );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.args) ), ((object) (en.args) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.ret) ), ((object) (en.ret) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TFunction", new object[]{this.args, this.ret});
		}
		
		
		public readonly global::Array<object> args;
		
		public readonly global::haxe.macro.ComplexType ret;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TAnonymous : global::haxe.macro.ComplexType {
		
		public ComplexType_TAnonymous(global::Array<object> fields) : base(2) {
			this.fields = fields;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.fields});
		}
		
		
		public override string getTag() {
			return "TAnonymous";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.fields});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TAnonymous en = ( other as global::haxe.macro.ComplexType_TAnonymous );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.fields) ), ((object) (en.fields) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TAnonymous", new object[]{this.fields});
		}
		
		
		public readonly global::Array<object> fields;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TParent : global::haxe.macro.ComplexType {
		
		public ComplexType_TParent(global::haxe.macro.ComplexType t) : base(3) {
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t});
		}
		
		
		public override string getTag() {
			return "TParent";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(3, new object[]{this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TParent en = ( other as global::haxe.macro.ComplexType_TParent );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TParent", new object[]{this.t});
		}
		
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TExtend : global::haxe.macro.ComplexType {
		
		public ComplexType_TExtend(global::Array<object> p, global::Array<object> fields) : base(4) {
			this.p = p;
			this.fields = fields;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.p, this.fields});
		}
		
		
		public override string getTag() {
			return "TExtend";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(4, new object[]{this.p, this.fields});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TExtend en = ( other as global::haxe.macro.ComplexType_TExtend );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.p) ), ((object) (en.p) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.fields) ), ((object) (en.fields) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TExtend", new object[]{this.p, this.fields});
		}
		
		
		public readonly global::Array<object> p;
		
		public readonly global::Array<object> fields;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TOptional : global::haxe.macro.ComplexType {
		
		public ComplexType_TOptional(global::haxe.macro.ComplexType t) : base(5) {
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t});
		}
		
		
		public override string getTag() {
			return "TOptional";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(5, new object[]{this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TOptional en = ( other as global::haxe.macro.ComplexType_TOptional );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TOptional", new object[]{this.t});
		}
		
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TNamed : global::haxe.macro.ComplexType {
		
		public ComplexType_TNamed(string n, global::haxe.macro.ComplexType t) : base(6) {
			this.n = n;
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.n, this.t});
		}
		
		
		public override string getTag() {
			return "TNamed";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(6, new object[]{this.n, this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TNamed en = ( other as global::haxe.macro.ComplexType_TNamed );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.n) ), ((object) (en.n) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TNamed", new object[]{this.n, this.t});
		}
		
		
		public readonly string n;
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ComplexType_TIntersection : global::haxe.macro.ComplexType {
		
		public ComplexType_TIntersection(global::Array<object> tl) : base(7) {
			this.tl = tl;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.tl});
		}
		
		
		public override string getTag() {
			return "TIntersection";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(7, new object[]{this.tl});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ComplexType_TIntersection en = ( other as global::haxe.macro.ComplexType_TIntersection );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.tl) ), ((object) (en.tl) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TIntersection", new object[]{this.tl});
		}
		
		
		public readonly global::Array<object> tl;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class TypeParam : global::haxe.lang.Enum {
		
		protected TypeParam(int index) : base(index) {
		}
		
		
		public static global::haxe.macro.TypeParam TPType(global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.TypeParam_TPType(t);
		}
		
		
		public static global::haxe.macro.TypeParam TPExpr(object e) {
			return new global::haxe.macro.TypeParam_TPExpr(e);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"TPType", "TPExpr"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeParam_TPType : global::haxe.macro.TypeParam {
		
		public TypeParam_TPType(global::haxe.macro.ComplexType t) : base(0) {
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t});
		}
		
		
		public override string getTag() {
			return "TPType";
		}
		
		
		public override int GetHashCode() {
			return global::haxe.lang.Enum.paramsGetHashCode(0, new object[]{this.t});
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeParam_TPType en = ( other as global::haxe.macro.TypeParam_TPType );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TPType", new object[]{this.t});
		}
		
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeParam_TPExpr : global::haxe.macro.TypeParam {
		
		public TypeParam_TPExpr(object e) : base(1) {
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.e});
		}
		
		
		public override string getTag() {
			return "TPExpr";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeParam_TPExpr en = ( other as global::haxe.macro.TypeParam_TPExpr );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TPExpr", new object[]{this.e});
		}
		
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class Access : global::haxe.lang.Enum {
		
		protected Access(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.Access APublic = new global::haxe.macro.Access_APublic();
		
		public static readonly global::haxe.macro.Access APrivate = new global::haxe.macro.Access_APrivate();
		
		public static readonly global::haxe.macro.Access AStatic = new global::haxe.macro.Access_AStatic();
		
		public static readonly global::haxe.macro.Access AOverride = new global::haxe.macro.Access_AOverride();
		
		public static readonly global::haxe.macro.Access ADynamic = new global::haxe.macro.Access_ADynamic();
		
		public static readonly global::haxe.macro.Access AInline = new global::haxe.macro.Access_AInline();
		
		public static readonly global::haxe.macro.Access AMacro = new global::haxe.macro.Access_AMacro();
		
		public static readonly global::haxe.macro.Access AFinal = new global::haxe.macro.Access_AFinal();
		
		public static readonly global::haxe.macro.Access AExtern = new global::haxe.macro.Access_AExtern();
		
		public static readonly global::haxe.macro.Access AAbstract = new global::haxe.macro.Access_AAbstract();
		
		public static readonly global::haxe.macro.Access AOverload = new global::haxe.macro.Access_AOverload();
		
		protected static readonly string[] __hx_constructs = new string[]{"APublic", "APrivate", "AStatic", "AOverride", "ADynamic", "AInline", "AMacro", "AFinal", "AExtern", "AAbstract", "AOverload"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_APublic : global::haxe.macro.Access {
		
		public Access_APublic() : base(0) {
		}
		
		
		public override string getTag() {
			return "APublic";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_APrivate : global::haxe.macro.Access {
		
		public Access_APrivate() : base(1) {
		}
		
		
		public override string getTag() {
			return "APrivate";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AStatic : global::haxe.macro.Access {
		
		public Access_AStatic() : base(2) {
		}
		
		
		public override string getTag() {
			return "AStatic";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AOverride : global::haxe.macro.Access {
		
		public Access_AOverride() : base(3) {
		}
		
		
		public override string getTag() {
			return "AOverride";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_ADynamic : global::haxe.macro.Access {
		
		public Access_ADynamic() : base(4) {
		}
		
		
		public override string getTag() {
			return "ADynamic";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AInline : global::haxe.macro.Access {
		
		public Access_AInline() : base(5) {
		}
		
		
		public override string getTag() {
			return "AInline";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AMacro : global::haxe.macro.Access {
		
		public Access_AMacro() : base(6) {
		}
		
		
		public override string getTag() {
			return "AMacro";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AFinal : global::haxe.macro.Access {
		
		public Access_AFinal() : base(7) {
		}
		
		
		public override string getTag() {
			return "AFinal";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AExtern : global::haxe.macro.Access {
		
		public Access_AExtern() : base(8) {
		}
		
		
		public override string getTag() {
			return "AExtern";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AAbstract : global::haxe.macro.Access {
		
		public Access_AAbstract() : base(9) {
		}
		
		
		public override string getTag() {
			return "AAbstract";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class Access_AOverload : global::haxe.macro.Access {
		
		public Access_AOverload() : base(10) {
		}
		
		
		public override string getTag() {
			return "AOverload";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class FieldType : global::haxe.lang.Enum {
		
		protected FieldType(int index) : base(index) {
		}
		
		
		public static global::haxe.macro.FieldType FVar(global::haxe.macro.ComplexType t, object e) {
			return new global::haxe.macro.FieldType_FVar(t, e);
		}
		
		
		public static global::haxe.macro.FieldType FFun(object f) {
			return new global::haxe.macro.FieldType_FFun(f);
		}
		
		
		public static global::haxe.macro.FieldType FProp(string @get, string @set, global::haxe.macro.ComplexType t, object e) {
			return new global::haxe.macro.FieldType_FProp(@get, @set, t, e);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"FVar", "FFun", "FProp"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FieldType_FVar : global::haxe.macro.FieldType {
		
		public FieldType_FVar(global::haxe.macro.ComplexType t, object e) : base(0) {
			this.t = t;
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t, this.e});
		}
		
		
		public override string getTag() {
			return "FVar";
		}
		
		
		public override int GetHashCode() {
			return global::haxe.lang.Enum.paramsGetHashCode(0, new object[]{this.t, this.e});
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.FieldType_FVar en = ( other as global::haxe.macro.FieldType_FVar );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("FVar", new object[]{this.t, this.e});
		}
		
		
		public readonly global::haxe.macro.ComplexType t;
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FieldType_FFun : global::haxe.macro.FieldType {
		
		public FieldType_FFun(object f) : base(1) {
			this.f = f;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.f});
		}
		
		
		public override string getTag() {
			return "FFun";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.f});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.FieldType_FFun en = ( other as global::haxe.macro.FieldType_FFun );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.f) ), ((object) (en.f) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("FFun", new object[]{this.f});
		}
		
		
		public readonly object f;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class FieldType_FProp : global::haxe.macro.FieldType {
		
		public FieldType_FProp(string @get, string @set, global::haxe.macro.ComplexType t, object e) : base(2) {
			this.@get = @get;
			this.@set = @set;
			this.t = t;
			this.e = e;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.@get, this.@set, this.t, this.e});
		}
		
		
		public override string getTag() {
			return "FProp";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.@get, this.@set, this.t, this.e});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.FieldType_FProp en = ( other as global::haxe.macro.FieldType_FProp );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.@get) ), ((object) (en.@get) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.@set) ), ((object) (en.@set) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.e) ), ((object) (en.e) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("FProp", new object[]{this.@get, this.@set, this.t, this.e});
		}
		
		
		public readonly string @get;
		
		public readonly string @set;
		
		public readonly global::haxe.macro.ComplexType t;
		
		public readonly object e;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class TypeDefKind : global::haxe.lang.Enum {
		
		protected TypeDefKind(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.TypeDefKind TDEnum = new global::haxe.macro.TypeDefKind_TDEnum();
		
		public static readonly global::haxe.macro.TypeDefKind TDStructure = new global::haxe.macro.TypeDefKind_TDStructure();
		
		public static global::haxe.macro.TypeDefKind TDClass(object superClass, global::Array<object> interfaces, global::haxe.lang.Null<bool> isInterface, global::haxe.lang.Null<bool> isFinal, global::haxe.lang.Null<bool> isAbstract) {
			return new global::haxe.macro.TypeDefKind_TDClass(superClass, interfaces, isInterface, isFinal, isAbstract);
		}
		
		
		public static global::haxe.macro.TypeDefKind TDAlias(global::haxe.macro.ComplexType t) {
			return new global::haxe.macro.TypeDefKind_TDAlias(t);
		}
		
		
		public static global::haxe.macro.TypeDefKind TDAbstract(global::haxe.macro.ComplexType tthis, global::Array<object> flags, global::Array<object> @from, global::Array<object> to) {
			return new global::haxe.macro.TypeDefKind_TDAbstract(tthis, flags, @from, to);
		}
		
		
		public static global::haxe.macro.TypeDefKind TDField(global::haxe.macro.FieldType kind, global::Array<object> access) {
			return new global::haxe.macro.TypeDefKind_TDField(kind, access);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"TDEnum", "TDStructure", "TDClass", "TDAlias", "TDAbstract", "TDField"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDEnum : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDEnum() : base(0) {
		}
		
		
		public override string getTag() {
			return "TDEnum";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDStructure : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDStructure() : base(1) {
		}
		
		
		public override string getTag() {
			return "TDStructure";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDClass : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDClass(object superClass, global::Array<object> interfaces, global::haxe.lang.Null<bool> isInterface, global::haxe.lang.Null<bool> isFinal, global::haxe.lang.Null<bool> isAbstract) : base(2) {
			this.superClass = superClass;
			this.interfaces = interfaces;
			this.isInterface = isInterface;
			this.isFinal = isFinal;
			this.isAbstract = isAbstract;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.superClass, this.interfaces, (this.isInterface).toDynamic(), (this.isFinal).toDynamic(), (this.isAbstract).toDynamic()});
		}
		
		
		public override string getTag() {
			return "TDClass";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.superClass, this.interfaces, (this.isInterface).toDynamic(), (this.isFinal).toDynamic(), (this.isAbstract).toDynamic()});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeDefKind_TDClass en = ( other as global::haxe.macro.TypeDefKind_TDClass );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.superClass) ), ((object) (en.superClass) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.interfaces) ), ((object) (en.interfaces) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>((this.isInterface).toDynamic(), (en.isInterface).toDynamic())) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>((this.isFinal).toDynamic(), (en.isFinal).toDynamic())) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>((this.isAbstract).toDynamic(), (en.isAbstract).toDynamic())) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TDClass", new object[]{this.superClass, this.interfaces, (this.isInterface).toDynamic(), (this.isFinal).toDynamic(), (this.isAbstract).toDynamic()});
		}
		
		
		public readonly object superClass;
		
		public readonly global::Array<object> interfaces;
		
		public readonly global::haxe.lang.Null<bool> isInterface;
		
		public readonly global::haxe.lang.Null<bool> isFinal;
		
		public readonly global::haxe.lang.Null<bool> isAbstract;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDAlias : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDAlias(global::haxe.macro.ComplexType t) : base(3) {
			this.t = t;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.t});
		}
		
		
		public override string getTag() {
			return "TDAlias";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(3, new object[]{this.t});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeDefKind_TDAlias en = ( other as global::haxe.macro.TypeDefKind_TDAlias );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.t) ), ((object) (en.t) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TDAlias", new object[]{this.t});
		}
		
		
		public readonly global::haxe.macro.ComplexType t;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDAbstract : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDAbstract(global::haxe.macro.ComplexType tthis, global::Array<object> flags, global::Array<object> @from, global::Array<object> to) : base(4) {
			this.tthis = tthis;
			this.flags = flags;
			this.@from = @from;
			this.to = to;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.tthis, this.flags, this.@from, this.to});
		}
		
		
		public override string getTag() {
			return "TDAbstract";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(4, new object[]{this.tthis, this.flags, this.@from, this.to});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeDefKind_TDAbstract en = ( other as global::haxe.macro.TypeDefKind_TDAbstract );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.tthis) ), ((object) (en.tthis) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.flags) ), ((object) (en.flags) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.@from) ), ((object) (en.@from) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.to) ), ((object) (en.to) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TDAbstract", new object[]{this.tthis, this.flags, this.@from, this.to});
		}
		
		
		public readonly global::haxe.macro.ComplexType tthis;
		
		public readonly global::Array<object> flags;
		
		public readonly global::Array<object> @from;
		
		public readonly global::Array<object> to;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class TypeDefKind_TDField : global::haxe.macro.TypeDefKind {
		
		public TypeDefKind_TDField(global::haxe.macro.FieldType kind, global::Array<object> access) : base(5) {
			this.kind = kind;
			this.access = access;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.kind, this.access});
		}
		
		
		public override string getTag() {
			return "TDField";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(5, new object[]{this.kind, this.access});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.TypeDefKind_TDField en = ( other as global::haxe.macro.TypeDefKind_TDField );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.kind) ), ((object) (en.kind) ))) ) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.access) ), ((object) (en.access) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("TDField", new object[]{this.kind, this.access});
		}
		
		
		public readonly global::haxe.macro.FieldType kind;
		
		public readonly global::Array<object> access;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class AbstractFlag : global::haxe.lang.Enum {
		
		protected AbstractFlag(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.AbstractFlag AbEnum = new global::haxe.macro.AbstractFlag_AbEnum();
		
		public static global::haxe.macro.AbstractFlag AbFrom(global::haxe.macro.ComplexType ct) {
			return new global::haxe.macro.AbstractFlag_AbFrom(ct);
		}
		
		
		public static global::haxe.macro.AbstractFlag AbTo(global::haxe.macro.ComplexType ct) {
			return new global::haxe.macro.AbstractFlag_AbTo(ct);
		}
		
		
		protected static readonly string[] __hx_constructs = new string[]{"AbEnum", "AbFrom", "AbTo"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class AbstractFlag_AbEnum : global::haxe.macro.AbstractFlag {
		
		public AbstractFlag_AbEnum() : base(0) {
		}
		
		
		public override string getTag() {
			return "AbEnum";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class AbstractFlag_AbFrom : global::haxe.macro.AbstractFlag {
		
		public AbstractFlag_AbFrom(global::haxe.macro.ComplexType ct) : base(1) {
			this.ct = ct;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.ct});
		}
		
		
		public override string getTag() {
			return "AbFrom";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.ct});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.AbstractFlag_AbFrom en = ( other as global::haxe.macro.AbstractFlag_AbFrom );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.ct) ), ((object) (en.ct) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("AbFrom", new object[]{this.ct});
		}
		
		
		public readonly global::haxe.macro.ComplexType ct;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class AbstractFlag_AbTo : global::haxe.macro.AbstractFlag {
		
		public AbstractFlag_AbTo(global::haxe.macro.ComplexType ct) : base(2) {
			this.ct = ct;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.ct});
		}
		
		
		public override string getTag() {
			return "AbTo";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(2, new object[]{this.ct});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.AbstractFlag_AbTo en = ( other as global::haxe.macro.AbstractFlag_AbTo );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.ct) ), ((object) (en.ct) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("AbTo", new object[]{this.ct});
		}
		
		
		public readonly global::haxe.macro.ComplexType ct;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class Error : global::haxe.Exception {
		
		public Error(global::haxe.lang.EmptyObject empty) : base(global::haxe.lang.EmptyObject.EMPTY) {
		}
		
		
		public Error(string message, object pos, global::haxe.Exception previous) : base(((string) (message) ), ((global::haxe.Exception) (( (( previous == null )) ? (null) : (previous) )) ), default(object)) {
			{
				this.pos = pos;
			}
			
			this.__shiftStack();
		}
		
		
		public object pos;
		
		public global::Array<object> childErrors;
		
		public override double __hx_setField_f(string field, int hash, double @value, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 5594516:
					{
						this.pos = ((object) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField_f(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override object __hx_setField(string field, int hash, object @value, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 1592770151:
					{
						this.childErrors = ((global::Array<object>) (global::Array<object>.__hx_cast<object>(((global::Array) (@value) ))) );
						return @value;
					}
					
					
					case 5594516:
					{
						this.pos = ((object) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override object __hx_getField(string field, int hash, bool throwErrors, bool isCheck, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 1592770151:
					{
						return this.childErrors;
					}
					
					
					case 5594516:
					{
						return this.pos;
					}
					
					
					default:
					{
						return base.__hx_getField(field, hash, throwErrors, isCheck, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override double __hx_getField_f(string field, int hash, bool throwErrors, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 5594516:
					{
						return ((double) (global::haxe.lang.Runtime.toDouble(this.pos)) );
					}
					
					
					default:
					{
						return base.__hx_getField_f(field, hash, throwErrors, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override void __hx_getFields(global::Array<string> baseArr) {
			baseArr.push("childErrors");
			baseArr.push("pos");
			base.__hx_getFields(baseArr);
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public class ImportMode : global::haxe.lang.Enum {
		
		protected ImportMode(int index) : base(index) {
		}
		
		
		public static readonly global::haxe.macro.ImportMode INormal = new global::haxe.macro.ImportMode_INormal();
		
		public static global::haxe.macro.ImportMode IAsName(string alias) {
			return new global::haxe.macro.ImportMode_IAsName(alias);
		}
		
		
		public static readonly global::haxe.macro.ImportMode IAll = new global::haxe.macro.ImportMode_IAll();
		
		protected static readonly string[] __hx_constructs = new string[]{"INormal", "IAsName", "IAll"};
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ImportMode_INormal : global::haxe.macro.ImportMode {
		
		public ImportMode_INormal() : base(0) {
		}
		
		
		public override string getTag() {
			return "INormal";
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ImportMode_IAsName : global::haxe.macro.ImportMode {
		
		public ImportMode_IAsName(string alias) : base(1) {
			this.alias = alias;
		}
		
		
		public override global::Array<object> getParams() {
			return new global::Array<object>(new object[]{this.alias});
		}
		
		
		public override string getTag() {
			return "IAsName";
		}
		
		
		public override int GetHashCode() {
			unchecked {
				return global::haxe.lang.Enum.paramsGetHashCode(1, new object[]{this.alias});
			}
		}
		
		
		public override bool Equals(object other) {
			if (global::System.Object.ReferenceEquals(((object) (this) ), ((object) (other) ))) {
				return true;
			}
			
			global::haxe.macro.ImportMode_IAsName en = ( other as global::haxe.macro.ImportMode_IAsName );
			if (( en == null )) {
				return false;
			}
			
			if ( ! (global::Type.enumEq<object>(((object) (this.alias) ), ((object) (en.alias) ))) ) {
				return false;
			}
			
			return true;
		}
		
		
		public override string toString() {
			return global::haxe.lang.Enum.paramsToString("IAsName", new object[]{this.alias});
		}
		
		
		public readonly string alias;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace haxe.macro {
	public sealed class ImportMode_IAll : global::haxe.macro.ImportMode {
		
		public ImportMode_IAll() : base(2) {
		}
		
		
		public override string getTag() {
			return "IAll";
		}
		
		
	}
}