solcparser

type ArrayTypeName struct {
	Node

	BaseTypeName interface{}
	Length       interface{}
}

type AssemblyAssignment struct {
	Expression interface{}
}

type AssemblyBlock struct {
	Operations []interface{}
}

type AssemblyCall struct {
	Arguments []interface{}
}

type AssemblyCase struct {
	Block interface{}
}

type AssemblyFor struct {
	Pre       interface{}
	Condition interface{}
	Post      interface{}
	Body      interface{}
}

type AssemblyFunctionDefinition struct {
	Body interface{}
}

type AssemblyIf struct {
	Condition interface{}
	Body      interface{}
}

type AssemblyLiteral struct {
}

type AssemblyLocalDefinition struct {
	Expression interface{}
}

type AssemblyMember struct {
	Expression interface{}
	MemberName interface{}
}

type AssemblySwitch struct {
	Expression interface{}
	Cases      []interface{}
}

type BinaryOperation struct {
	Node

	Operator string
	Left     interface{}
	Right    interface{}
}

type Block struct {
	Node

	Statements []interface{}
}

type BooleanLiteral struct {
	Node

	Value bool
}

type BreakStatement struct {
	Node
}

type CatchClause struct {
	Node

	IsReasonType bool
	Kind         string
	Parameters   interface{}
	Body         interface{}
}

type Conditional struct {
	Node

	Condition       interface{}
	TrueExpression  interface{}
	FalseExpression interface{}
}

type ContinueStatement struct {
	Node
}

type ContractDefinition struct {
	Node

	Name          string `json:"name"`
	SubNodes      []interface{}
	BaseContracts []interface{}
	Kind          string
}

type CustomErrorDefinition struct {
	Node

	Name       string
	Parameters []interface{}
}

type CustomErrorListener struct {
	*antlr.DefaultErrorListener
	Errors []*SyntaxError
}

type DoWhileStatement struct {
	Node

	Condition interface{}
	Body      interface{}
}

type ElementaryTypeName struct {
	Node

	Name            string
	StateMutability string
}

type EmitStatement struct {
	Node

	EventCall interface{}
}

type EnumDefinition struct {
	Node

	Name    string        `json:"name"`
	Members []interface{} `json:"members"`
}

type EnumValue struct {
	Node

	Name string `json:"name"`
}

type EventDefinition struct {
	Node

	Name       string
	Parameters []interface{}
}

type ExpressionStatement struct {
	Node

	Expression interface{}
}

type FileLevelConstant struct {
	Node

	Name            string
	InitialValue    interface{}
	TypeName        interface{}
	IsDeclaredConst bool
	IsImmutable     bool
}

type ForStatement struct {
	Node

	InitExpression      interface{}
	ConditionExpression interface{}
	LoopExpression      interface{}
	Body                interface{}
}

type FunctionCall struct {
	Node

	Arguments   []interface{}
	Names       []interface{}
	Identifiers []interface{}
	Expression  interface{}
}

type FunctionDefinition struct {
	Node

	Name             string
	Parameters       []interface{}
	Modifiers        []interface{}
	ReturnParameters interface{}
	Body             interface{}
	StateMutability  string
	Visibility       string
	IsConstructor    bool
	IsReceiveEther   bool
	IsFallback       bool
	IsVirtual        bool
	Override         []interface{}
}

type FunctionTypeName struct {
	Node

	ParameterTypes  []interface{}
	ReturnTypes     []interface{}
	Visibility      string
	StateMutability string
}

type HexLiteral struct {
	Node

	Value string
	Parts []string
}

type INode interface {
	GetType() string
	IsNode()
	SetTypeName(s string)
}

type Identifier struct {
	Node

	Name string
}

type IfStatement struct {
	Node

	Condition interface{}
	TrueBody  interface{}
	FalseBody interface{}
}

type ImportDirective struct {
	Node

	Path        string
	PathLiteral interface{}

	UnitAlias           string
	UnitAliasIdentifier interface{}

	SymbolAliases            [][]string
	SymbolAliasesIdentifiers [][]*Identifier
}

type IndexAccess struct {
	Node

	Base  interface{}
	Index interface{}
}

type IndexRangeAccess struct {
	Node

	Base       interface{}
	IndexStart interface{}
	IndexEnd   interface{}
}

type InheritanceSpecifier struct {
	Node

	BaseName  interface{}
	Arguments []interface{}
}

type InlineAssemblyStatement struct {
	Body interface{}
}

type Mapping struct {
	Node

	KeyType   interface{}
	ValueType interface{}
}

type MemberAccess struct {
	Node

	Expression interface{}
	MemberName string
}

type ModifierDefinition struct {
	Node

	Name       string
	Parameters interface{}
	Body       interface{}
	IsVirtual  bool
	Override   []interface{}
}

type ModifierInvocation struct {
	Node

	Name      string
	Arguments []interface{}
}

type NameValueExpression struct {
	Node

	Expression interface{}
	Arguments  interface{}
}

type NameValueList struct {
	Node

	Names       []string
	Identifiers []interface{}
	Args        []interface{}
}

type NewExpression struct {
	Node

	TypeName interface{}
}

type Node struct {
	Type string `json:"type"`
}

type NumberLiteral struct {
	Node

	Number          string
	SubDenomination interface{}
}

type OverrideSpecifier struct {
	Node
}

type Parser struct {
	Result INode
	Errors []*SyntaxError
}

type PragmaDirective struct {
	Node

	Name  string
	Value string
}

type ReturnStatement struct {
	Node

	Expression interface{}
}

type RevertStatement struct {
	Node

	RevertCall interface{}
}

type SourceUnit struct {
	Node

	Children []interface{}
}

type StateVariableDeclaration struct {
	Node

	Variables    []interface{}
	InitialValue interface{}
}

type StateVariableDeclarationVariable struct {
	VariableDeclaration
	IsInmutable bool
}

type StringLiteral struct {
	Node

	Value     string
	Parts     []string
	IsUnicode []bool
}

type StructDefinition struct {
	Node

	Name    string
	Members []interface{}
}

type SyntaxError struct {
	// contains filtered or unexported fields
}

type ThrowStatement struct {
	Node
}

type TryStatement struct {
	Node

	Expression       interface{}
	CatchClause      []interface{}
	Body             interface{}
	ReturnParameters interface{}
}

type TupleExpression struct {
	Node

	Components []interface{}
	IsArray    bool
}

type TypeDefinition struct {
	Node

	Name       string
	Definition interface{}
}

type TypeNameExpression struct {
	Node

	TypeName interface{}
}

type UnaryOperation struct {
	Node

	Operator      string
	SubExpression interface{}
	IsPrefix      bool
}

type UncheckedStatement struct {
	Node

	Block interface{}
}

type UserDefinedTypeName struct {
	Node

	NamePath string
}

type UsingForDeclaration struct {
	Node

	LibraryName string
	TypeName    interface{}
}

type VariableDeclaration struct {
	Node

	Name            string
	TypeName        interface{}
	Identifier      interface{}
	IsIndexed       bool
	IsStateVar      bool
	IsDeclaredConst bool
	StorageLocation string
	Expression      interface{}
	Visibility      string
	Override        []interface{}
}

type VariableDeclarationStatement struct {
	Node

	InitialValue interface{}
	Variables    []interface{}
}

type WhileStatement struct {
	Node

	Condition interface{}
	Body      interface{}
}