gopherscript

type AbsolutePathExpression struct {
	NodeBase
	Slices []Node
}

type AbsolutePathLiteral struct {
	NodeBase
	Value string
}

type AbsolutePathPatternLiteral struct {
	NodeBase
	Value string
}

type Assignment struct {
	NodeBase
	Left  Node
	Right Node
}

type AtHostLiteral struct {
	NodeBase
	Value string
}

type BinaryExpression struct {
	NodeBase
	Operator BinaryOperator
	Left     Node
	Right    Node
}

type BinaryOperator int

type Block struct {
	NodeBase
	Statements []Node
}

type BooleanConversionExpression struct {
	NodeBase
	Expr Node
}

type BooleanLiteral struct {
	NodeBase
	Value bool
}

type BreakStatement struct {
	NodeBase
	Label *IdentifierLiteral //can be nil
}

type ByteCount int

type ByteRate int

type Call struct {
	NodeBase
	Callee    Node
	Arguments []Node
	Must      bool
}

type Case struct {
	NodeBase
	Value Node
	Block *Block
}

type CommandPermission struct {
	CommandName         string
	SubcommandNameChain []string //can be empty
}

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

type ContextlessCallPermission struct {
	FuncMethodName   string
	ReceiverTypeName string
}

type ContinueStatement struct {
	NodeBase
	Label *IdentifierLiteral //can be nil
}

type EmbeddedModule struct {
	NodeBase
	Requirements *Requirements
	Statements   []Node
}

type EntryMatcher struct {
	Key   Matcher
	Value Matcher
}

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

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

type ExtractionExpression struct {
	NodeBase
	Object Node
	Keys   *KeyListExpression
}

type FilesystemPermission struct {
	Kind_  PermissionKind
	Entity interface{} //Path, PathPattern ...
}

type FloatLiteral struct {
	NodeBase
	Raw   string
	Value float64
}

type ForStatement struct {
	NodeBase
	KeyIndexIdent  *IdentifierLiteral //can be nil
	ValueElemIdent *IdentifierLiteral //can be nil
	Body           *Block
	IteratedValue  Node
}

type Func Node

type FunctionDeclaration struct {
	NodeBase
	Function *FunctionExpression
	Name     *IdentifierLiteral
}

type FunctionExpression struct {
	NodeBase
	Parameters   []*FunctionParameter
	Body         *Block
	Requirements *Requirements
}

type FunctionParameter struct {
	NodeBase
	Var *IdentifierLiteral
}

type GenerativePattern interface {
	Random() interface{}
}

type GlobalConstantDeclaration struct {
	NodeBase
	Left  *IdentifierLiteral
	Right Node
}

type GlobalConstantDeclarations struct {
	NodeBase
	Declarations []*GlobalConstantDeclaration
}

type GlobalVarPermission struct {
	Kind_ PermissionKind
	Name  string //"*" means any
}

type GlobalVariable struct {
	NodeBase
	Name string
}

type GroupMatcher interface {
	Matcher
	MatchGroups(interface{}) (ok bool, groups map[string]interface{})
}

type HTTPHost string

type HTTPHostLiteral struct {
	NodeBase
	Value string
}

type HTTPHostPattern string

type HTTPHostPatternLiteral struct {
	NodeBase
	Value string
}

type HostAliasDefinition struct {
	NodeBase
	Left  *AtHostLiteral
	Right Node
}

type HttpPermission struct {
	Kind_  PermissionKind
	Entity interface{} //URL, URLPattern, HTTPHost, HTTPHostPattern ....
}

type Identifier string

type IdentifierLiteral struct {
	NodeBase
	Name string
}

type IdentifierMemberExpression struct {
	NodeBase
	Left          *IdentifierLiteral
	PropertyNames []*IdentifierLiteral
}

type IfStatement struct {
	NodeBase
	Test       Node
	Consequent *Block
	Alternate  *Block //can be nil
}

type ImportStatement struct {
	NodeBase
	Identifier         *IdentifierLiteral
	URL                *URLLiteral
	ValidationString   *StringLiteral
	ArgumentObject     *ObjectLiteral
	GrantedPermissions *ObjectLiteral
}

type IndexExpression struct {
	NodeBase
	Indexed Node
	Index   Node
}

type IntLiteral struct {
	NodeBase
	Raw   string
	Value int
}

type IntRange struct {
	Start int
	End   int
	Step  int
	// contains filtered or unexported fields
}

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

type IntegerRangeLiteral struct {
	NodeBase
	LowerBound *IntLiteral
	UpperBound *IntLiteral
}

type InvalidAliasRelatedNode struct {
	NodeBase
	Value string
}

type InvalidComplexPatternElement struct {
	NodeBase
}

type InvalidMemberLike struct {
	NodeBase
	Left  Node
	Right Node //can be nil
}

type InvalidObjectElement struct {
	NodeBase
}

type InvalidURL struct {
	NodeBase
	Value string
}

type InvalidURLPattern struct {
	NodeBase
	Value string
}

type Iterable interface {
	Iterator() Iterator
}

type IterationChange int

type Iterator interface {
	HasNext(*Context) bool
	GetNext(*Context) interface{}
}

type JSONstring string

type KeyList []string

type KeyListExpression struct {
	NodeBase
	Keys []*IdentifierLiteral
}

type LazyExpression struct {
	NodeBase
	Expression Node
}

type Limitation struct {
	Name        string
	SimpleRate  SimpleRate
	ByteRate    ByteRate
	Total       int64
	DecrementFn func(time.Time) int64
}

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

type LineCount int

type List []interface{}

type ListLiteral struct {
	NodeBase
	Elements []Node
}

type ListPattern struct {
	ElementMatchers []Matcher
}

type ListPatternLiteral struct {
	NodeBase
	Elements []Node
}

type LoadType int

type MatchStatement struct {
	NodeBase
	Discriminant Node
	Cases        []*Case
}

type Matcher interface {
	Test(interface{}) bool
}

type MemberExpression struct {
	NodeBase
	Left         Node
	PropertyName *IdentifierLiteral
}

type MissingExpression struct {
	NodeBase
}

type Module struct {
	NodeBase
	GlobalConstantDeclarations *GlobalConstantDeclarations //nil if no const declarations at the top of the module
	Requirements               *Requirements               //nil if no require at the top of the module
	Statements                 []Node
}

type MultiAssignment struct {
	NodeBase
	Variables []Node
	Right     Node
}

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

type NamedSegmentPathPatternLiteral struct {
	NodeBase
	Slices []Node //PathSlice | Variable
}

type NilLiteral struct {
	NodeBase
}

type Node interface {
	Base() NodeBase
}

type NodeBase struct {
	Span            NodeSpan
	Err             *ParsingError
	ValuelessTokens []ValuelessToken
}

type NodeCategory int

type NodeSpan struct {
	Start int
	End   int
}

type NotAllowedError struct {
	Permission Permission
	Message    string
}

type Object map[string]interface{}

type ObjectLiteral struct {
	NodeBase
	Properties     []ObjectProperty
	SpreadElements []*PropertySpreadElement
}

type ObjectPattern struct {
	EntryMatchers map[string]Matcher
}

type ObjectPatternLiteral struct {
	NodeBase
	Properties []ObjectProperty
}

type ObjectProperty struct {
	NodeBase
	Key   Node //can be nil (implicit key)
	Value Node
}

type OcurrenceCountModifier int

type ParsingError struct {
	Message string
	Index   int

	NodeStartIndex int //< 0 if not specified
	NodeCategory   NodeCategory
	NodeType       Node //not nil if .NodeCategory is KnownType
}

type Path string

type PathPattern string

type PathSlice struct {
	NodeBase
	Value string
}

type PatternDefinition struct {
	NodeBase
	Left  *PatternIdentifierLiteral
	Right Node
}

type PatternIdentifierLiteral struct {
	NodeBase
	Name string
}

type PatternKind int

type PatternPiece struct {
	NodeBase
	Kind     PatternKind
	Elements []*PatternPieceElement
}

type PatternPieceElement struct {
	NodeBase
	Ocurrence           OcurrenceCountModifier
	ExactOcurrenceCount int
	Expr                Node
}

type PatternUnion struct {
	NodeBase
	Cases []Node
}

type Permission interface {
	Kind() PermissionKind
	Includes(Permission) bool
	String() string
}

type PermissionDroppingStatement struct {
	NodeBase
	Object *ObjectLiteral
}

type PermissionKind int

type PipelineExpression struct {
	NodeBase
	Stages []*PipelineStage
}

type PipelineStage struct {
	Kind PipelineStageKind
	Expr Node
}

type PipelineStageKind int

type PipelineStatement struct {
	NodeBase
	Stages []*PipelineStage
}

type PropertySpreadElement struct {
	NodeBase
	Extraction *ExtractionExpression
}

type QuantityLiteral struct {
	NodeBase
	Raw   string
	Value float64
	Unit  string
}

type QuantityRange struct {
	Start interface{}
	End   interface{}
	// contains filtered or unexported fields
}

type RateLiteral struct {
	NodeBase
	Quantity *QuantityLiteral
	Unit     *IdentifierLiteral
}

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

type RegularExpressionLiteral struct {
	NodeBase
	Raw   string
	Value string
}

type RelativePathExpression struct {
	NodeBase
	Slices []Node
}

type RelativePathLiteral struct {
	NodeBase
	Value string
}

type RelativePathPatternLiteral struct {
	NodeBase
	Value string
}

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

type Requirements struct {
	ValuelessTokens []ValuelessToken
	Object          *ObjectLiteral
}

type ReturnStatement struct {
	NodeBase
	Expr Node
}

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

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

type RoutinePermission struct {
	Kind_ PermissionKind
}

type RuneLiteral struct {
	NodeBase
	Value rune
}

type RuneRange struct {
	Start rune
	End   rune
}

type RuneRangeExpression struct {
	NodeBase
	Lower *RuneLiteral
	Upper *RuneLiteral
}

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

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

type SimpleRate int

type SliceExpression struct {
	NodeBase
	Indexed    Node
	StartIndex Node //can be nil
	EndIndex   Node //can be nil
}

type SpawnExpression struct {
	NodeBase
	GroupIdent         *IdentifierLiteral //can be nil
	Globals            Node
	ExprOrVar          Node
	GrantedPermissions *ObjectLiteral //nil if no "allow ...." in the spawn expression
}

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

type State struct {
	ScopeStack  []map[string]interface{}
	ReturnValue *interface{}
	IterationChange

	Script     []rune
	ScriptName string
	// contains filtered or unexported fields
}

type Statement interface {
	Node
}

type StringLiteral struct {
	NodeBase
	Raw   string
	Value string
}

type StringPatternElement interface {
	Matcher
	GenerativePattern
	Regex() string
}

type SwitchStatement struct {
	NodeBase
	Discriminant Node
	Cases        []*Case
}

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

type TraversalAction int

type TraversalConfiguration struct {
	MaxDepth int
}

type TraversalOrder int

type URL string

type URLExpression struct {
	NodeBase
	Raw         string
	HostPart    Node
	Path        *AbsolutePathExpression
	QueryParams []Node
}

type URLLiteral struct {
	NodeBase
	Value string
}

type URLPattern string

type URLPatternLiteral struct {
	NodeBase
	Value string
}

type URLQueryExpression struct {
	NodeBase
	Parameters map[string][]Node
}

type URLQueryParameter struct {
	NodeBase
	Name  string
	Value []Node
}

type URLQueryParameterSlice struct {
	NodeBase
	Value string
}

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

type UnknownNode struct {
	NodeBase
}

type UpperBoundRangeExpression struct {
	NodeBase
	UpperBound Node
}

type ValuelessToken struct {
	Type ValuelessTokenType
	Span NodeSpan
}

type ValuelessTokenType int

type Variable struct {
	NodeBase
	Name string
}