kubernetes/vendor/github.com/google/cel-go/parser/gen/cel_parser.go

var _

var _

var _

type CELParser

var CELParserStaticData

func celParserInit() {}

// CELParserInit initializes any static state used to implement CELParser. By default the
// static state used to implement the parser is lazily initialized during the first call to
// NewCELParser(). You can call this function if you wish to initialize the static state ahead
// of time.
func CELParserInit() {}

// NewCELParser produces a new parser instance for the optional input antlr.TokenStream.
func NewCELParser(input antlr.TokenStream) *CELParser {}

const CELParserEOF

const CELParserEQUALS

const CELParserNOT_EQUALS

const CELParserIN

const CELParserLESS

const CELParserLESS_EQUALS

const CELParserGREATER_EQUALS

const CELParserGREATER

const CELParserLOGICAL_AND

const CELParserLOGICAL_OR

const CELParserLBRACKET

const CELParserRPRACKET

const CELParserLBRACE

const CELParserRBRACE

const CELParserLPAREN

const CELParserRPAREN

const CELParserDOT

const CELParserCOMMA

const CELParserMINUS

const CELParserEXCLAM

const CELParserQUESTIONMARK

const CELParserCOLON

const CELParserPLUS

const CELParserSTAR

const CELParserSLASH

const CELParserPERCENT

const CELParserCEL_TRUE

const CELParserCEL_FALSE

const CELParserNUL

const CELParserWHITESPACE

const CELParserCOMMENT

const CELParserNUM_FLOAT

const CELParserNUM_INT

const CELParserNUM_UINT

const CELParserSTRING

const CELParserBYTES

const CELParserIDENTIFIER

const CELParserRULE_start

const CELParserRULE_expr

const CELParserRULE_conditionalOr

const CELParserRULE_conditionalAnd

const CELParserRULE_relation

const CELParserRULE_calc

const CELParserRULE_unary

const CELParserRULE_member

const CELParserRULE_primary

const CELParserRULE_exprList

const CELParserRULE_listInit

const CELParserRULE_fieldInitializerList

const CELParserRULE_optField

const CELParserRULE_mapInitializerList

const CELParserRULE_optExpr

const CELParserRULE_literal

type IStartContext

type StartContext

func NewEmptyStartContext() *StartContext {}

func InitEmptyStartContext(p *StartContext)  {}

func (*StartContext) IsStartContext() {}

func NewStartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartContext {}

func (s *StartContext) GetParser() antlr.Parser {}

func (s *StartContext) GetE() IExprContext {}

func (s *StartContext) SetE(v IExprContext) {}

func (s *StartContext) EOF() antlr.TerminalNode {}

func (s *StartContext) Expr() IExprContext {}

func (s *StartContext) GetRuleContext() antlr.RuleContext {}

func (s *StartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *StartContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *StartContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *StartContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Start_() (localctx IStartContext) {}

type IExprContext

type ExprContext

func NewEmptyExprContext() *ExprContext {}

func InitEmptyExprContext(p *ExprContext)  {}

func (*ExprContext) IsExprContext() {}

func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext {}

func (s *ExprContext) GetParser() antlr.Parser {}

func (s *ExprContext) GetOp() antlr.Token {}

func (s *ExprContext) SetOp(v antlr.Token) {}

func (s *ExprContext) GetE() IConditionalOrContext {}

func (s *ExprContext) GetE1() IConditionalOrContext {}

func (s *ExprContext) GetE2() IExprContext {}

func (s *ExprContext) SetE(v IConditionalOrContext) {}

func (s *ExprContext) SetE1(v IConditionalOrContext) {}

func (s *ExprContext) SetE2(v IExprContext) {}

func (s *ExprContext) AllConditionalOr() []IConditionalOrContext {}

func (s *ExprContext) ConditionalOr(i int) IConditionalOrContext {}

func (s *ExprContext) COLON() antlr.TerminalNode {}

func (s *ExprContext) QUESTIONMARK() antlr.TerminalNode {}

func (s *ExprContext) Expr() IExprContext {}

func (s *ExprContext) GetRuleContext() antlr.RuleContext {}

func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Expr() (localctx IExprContext) {}

type IConditionalOrContext

type ConditionalOrContext

func NewEmptyConditionalOrContext() *ConditionalOrContext {}

func InitEmptyConditionalOrContext(p *ConditionalOrContext)  {}

func (*ConditionalOrContext) IsConditionalOrContext() {}

func NewConditionalOrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalOrContext {}

func (s *ConditionalOrContext) GetParser() antlr.Parser {}

func (s *ConditionalOrContext) GetS9() antlr.Token {}

func (s *ConditionalOrContext) SetS9(v antlr.Token) {}

func (s *ConditionalOrContext) GetOps() []antlr.Token {}

func (s *ConditionalOrContext) SetOps(v []antlr.Token) {}

func (s *ConditionalOrContext) GetE() IConditionalAndContext {}

func (s *ConditionalOrContext) Get_conditionalAnd() IConditionalAndContext {}

func (s *ConditionalOrContext) SetE(v IConditionalAndContext) {}

func (s *ConditionalOrContext) Set_conditionalAnd(v IConditionalAndContext) {}

func (s *ConditionalOrContext) GetE1() []IConditionalAndContext {}

func (s *ConditionalOrContext) SetE1(v []IConditionalAndContext) {}

func (s *ConditionalOrContext) AllConditionalAnd() []IConditionalAndContext {}

func (s *ConditionalOrContext) ConditionalAnd(i int) IConditionalAndContext {}

func (s *ConditionalOrContext) AllLOGICAL_OR() []antlr.TerminalNode {}

func (s *ConditionalOrContext) LOGICAL_OR(i int) antlr.TerminalNode {}

func (s *ConditionalOrContext) GetRuleContext() antlr.RuleContext {}

func (s *ConditionalOrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *ConditionalOrContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ConditionalOrContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ConditionalOrContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) ConditionalOr() (localctx IConditionalOrContext) {}

type IConditionalAndContext

type ConditionalAndContext

func NewEmptyConditionalAndContext() *ConditionalAndContext {}

func InitEmptyConditionalAndContext(p *ConditionalAndContext)  {}

func (*ConditionalAndContext) IsConditionalAndContext() {}

func NewConditionalAndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionalAndContext {}

func (s *ConditionalAndContext) GetParser() antlr.Parser {}

func (s *ConditionalAndContext) GetS8() antlr.Token {}

func (s *ConditionalAndContext) SetS8(v antlr.Token) {}

func (s *ConditionalAndContext) GetOps() []antlr.Token {}

func (s *ConditionalAndContext) SetOps(v []antlr.Token) {}

func (s *ConditionalAndContext) GetE() IRelationContext {}

func (s *ConditionalAndContext) Get_relation() IRelationContext {}

func (s *ConditionalAndContext) SetE(v IRelationContext) {}

func (s *ConditionalAndContext) Set_relation(v IRelationContext) {}

func (s *ConditionalAndContext) GetE1() []IRelationContext {}

func (s *ConditionalAndContext) SetE1(v []IRelationContext) {}

func (s *ConditionalAndContext) AllRelation() []IRelationContext {}

func (s *ConditionalAndContext) Relation(i int) IRelationContext {}

func (s *ConditionalAndContext) AllLOGICAL_AND() []antlr.TerminalNode {}

func (s *ConditionalAndContext) LOGICAL_AND(i int) antlr.TerminalNode {}

func (s *ConditionalAndContext) GetRuleContext() antlr.RuleContext {}

func (s *ConditionalAndContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *ConditionalAndContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ConditionalAndContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ConditionalAndContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) ConditionalAnd() (localctx IConditionalAndContext) {}

type IRelationContext

type RelationContext

func NewEmptyRelationContext() *RelationContext {}

func InitEmptyRelationContext(p *RelationContext)  {}

func (*RelationContext) IsRelationContext() {}

func NewRelationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RelationContext {}

func (s *RelationContext) GetParser() antlr.Parser {}

func (s *RelationContext) GetOp() antlr.Token {}

func (s *RelationContext) SetOp(v antlr.Token) {}

func (s *RelationContext) Calc() ICalcContext {}

func (s *RelationContext) AllRelation() []IRelationContext {}

func (s *RelationContext) Relation(i int) IRelationContext {}

func (s *RelationContext) LESS() antlr.TerminalNode {}

func (s *RelationContext) LESS_EQUALS() antlr.TerminalNode {}

func (s *RelationContext) GREATER_EQUALS() antlr.TerminalNode {}

func (s *RelationContext) GREATER() antlr.TerminalNode {}

func (s *RelationContext) EQUALS() antlr.TerminalNode {}

func (s *RelationContext) NOT_EQUALS() antlr.TerminalNode {}

func (s *RelationContext) IN() antlr.TerminalNode {}

func (s *RelationContext) GetRuleContext() antlr.RuleContext {}

func (s *RelationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *RelationContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *RelationContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *RelationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Relation() (localctx IRelationContext) {}

func (p *CELParser) relation(_p int) (localctx IRelationContext) {}

type ICalcContext

type CalcContext

func NewEmptyCalcContext() *CalcContext {}

func InitEmptyCalcContext(p *CalcContext)  {}

func (*CalcContext) IsCalcContext() {}

func NewCalcContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CalcContext {}

func (s *CalcContext) GetParser() antlr.Parser {}

func (s *CalcContext) GetOp() antlr.Token {}

func (s *CalcContext) SetOp(v antlr.Token) {}

func (s *CalcContext) Unary() IUnaryContext {}

func (s *CalcContext) AllCalc() []ICalcContext {}

func (s *CalcContext) Calc(i int) ICalcContext {}

func (s *CalcContext) STAR() antlr.TerminalNode {}

func (s *CalcContext) SLASH() antlr.TerminalNode {}

func (s *CalcContext) PERCENT() antlr.TerminalNode {}

func (s *CalcContext) PLUS() antlr.TerminalNode {}

func (s *CalcContext) MINUS() antlr.TerminalNode {}

func (s *CalcContext) GetRuleContext() antlr.RuleContext {}

func (s *CalcContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *CalcContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *CalcContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *CalcContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Calc() (localctx ICalcContext) {}

func (p *CELParser) calc(_p int) (localctx ICalcContext) {}

type IUnaryContext

type UnaryContext

func NewEmptyUnaryContext() *UnaryContext {}

func InitEmptyUnaryContext(p *UnaryContext)  {}

func (*UnaryContext) IsUnaryContext() {}

func NewUnaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryContext {}

func (s *UnaryContext) GetParser() antlr.Parser {}

func (s *UnaryContext) CopyAll(ctx *UnaryContext) {}

func (s *UnaryContext) GetRuleContext() antlr.RuleContext {}

func (s *UnaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

type LogicalNotContext

func NewLogicalNotContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalNotContext {}

func (s *LogicalNotContext) GetS19() antlr.Token {}

func (s *LogicalNotContext) SetS19(v antlr.Token) {}

func (s *LogicalNotContext) GetOps() []antlr.Token {}

func (s *LogicalNotContext) SetOps(v []antlr.Token) {}

func (s *LogicalNotContext) GetRuleContext() antlr.RuleContext {}

func (s *LogicalNotContext) Member() IMemberContext {}

func (s *LogicalNotContext) AllEXCLAM() []antlr.TerminalNode {}

func (s *LogicalNotContext) EXCLAM(i int) antlr.TerminalNode {}

func (s *LogicalNotContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *LogicalNotContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *LogicalNotContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type MemberExprContext

func NewMemberExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberExprContext {}

func (s *MemberExprContext) GetRuleContext() antlr.RuleContext {}

func (s *MemberExprContext) Member() IMemberContext {}

func (s *MemberExprContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *MemberExprContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *MemberExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type NegateContext

func NewNegateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NegateContext {}

func (s *NegateContext) GetS18() antlr.Token {}

func (s *NegateContext) SetS18(v antlr.Token) {}

func (s *NegateContext) GetOps() []antlr.Token {}

func (s *NegateContext) SetOps(v []antlr.Token) {}

func (s *NegateContext) GetRuleContext() antlr.RuleContext {}

func (s *NegateContext) Member() IMemberContext {}

func (s *NegateContext) AllMINUS() []antlr.TerminalNode {}

func (s *NegateContext) MINUS(i int) antlr.TerminalNode {}

func (s *NegateContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *NegateContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *NegateContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Unary() (localctx IUnaryContext) {}

type IMemberContext

type MemberContext

func NewEmptyMemberContext() *MemberContext {}

func InitEmptyMemberContext(p *MemberContext)  {}

func (*MemberContext) IsMemberContext() {}

func NewMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberContext {}

func (s *MemberContext) GetParser() antlr.Parser {}

func (s *MemberContext) CopyAll(ctx *MemberContext) {}

func (s *MemberContext) GetRuleContext() antlr.RuleContext {}

func (s *MemberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

type MemberCallContext

func NewMemberCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MemberCallContext {}

func (s *MemberCallContext) GetOp() antlr.Token {}

func (s *MemberCallContext) GetId() antlr.Token {}

func (s *MemberCallContext) GetOpen() antlr.Token {}

func (s *MemberCallContext) SetOp(v antlr.Token) {}

func (s *MemberCallContext) SetId(v antlr.Token) {}

func (s *MemberCallContext) SetOpen(v antlr.Token) {}

func (s *MemberCallContext) GetArgs() IExprListContext {}

func (s *MemberCallContext) SetArgs(v IExprListContext) {}

func (s *MemberCallContext) GetRuleContext() antlr.RuleContext {}

func (s *MemberCallContext) Member() IMemberContext {}

func (s *MemberCallContext) RPAREN() antlr.TerminalNode {}

func (s *MemberCallContext) DOT() antlr.TerminalNode {}

func (s *MemberCallContext) IDENTIFIER() antlr.TerminalNode {}

func (s *MemberCallContext) LPAREN() antlr.TerminalNode {}

func (s *MemberCallContext) ExprList() IExprListContext {}

func (s *MemberCallContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *MemberCallContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *MemberCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type SelectContext

func NewSelectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectContext {}

func (s *SelectContext) GetOp() antlr.Token {}

func (s *SelectContext) GetOpt() antlr.Token {}

func (s *SelectContext) GetId() antlr.Token {}

func (s *SelectContext) SetOp(v antlr.Token) {}

func (s *SelectContext) SetOpt(v antlr.Token) {}

func (s *SelectContext) SetId(v antlr.Token) {}

func (s *SelectContext) GetRuleContext() antlr.RuleContext {}

func (s *SelectContext) Member() IMemberContext {}

func (s *SelectContext) DOT() antlr.TerminalNode {}

func (s *SelectContext) IDENTIFIER() antlr.TerminalNode {}

func (s *SelectContext) QUESTIONMARK() antlr.TerminalNode {}

func (s *SelectContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *SelectContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *SelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type PrimaryExprContext

func NewPrimaryExprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PrimaryExprContext {}

func (s *PrimaryExprContext) GetRuleContext() antlr.RuleContext {}

func (s *PrimaryExprContext) Primary() IPrimaryContext {}

func (s *PrimaryExprContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *PrimaryExprContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *PrimaryExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type IndexContext

func NewIndexContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexContext {}

func (s *IndexContext) GetOp() antlr.Token {}

func (s *IndexContext) GetOpt() antlr.Token {}

func (s *IndexContext) SetOp(v antlr.Token) {}

func (s *IndexContext) SetOpt(v antlr.Token) {}

func (s *IndexContext) GetIndex() IExprContext {}

func (s *IndexContext) SetIndex(v IExprContext) {}

func (s *IndexContext) GetRuleContext() antlr.RuleContext {}

func (s *IndexContext) Member() IMemberContext {}

func (s *IndexContext) RPRACKET() antlr.TerminalNode {}

func (s *IndexContext) LBRACKET() antlr.TerminalNode {}

func (s *IndexContext) Expr() IExprContext {}

func (s *IndexContext) QUESTIONMARK() antlr.TerminalNode {}

func (s *IndexContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *IndexContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *IndexContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Member() (localctx IMemberContext) {}

func (p *CELParser) member(_p int) (localctx IMemberContext) {}

type IPrimaryContext

type PrimaryContext

func NewEmptyPrimaryContext() *PrimaryContext {}

func InitEmptyPrimaryContext(p *PrimaryContext)  {}

func (*PrimaryContext) IsPrimaryContext() {}

func NewPrimaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryContext {}

func (s *PrimaryContext) GetParser() antlr.Parser {}

func (s *PrimaryContext) CopyAll(ctx *PrimaryContext) {}

func (s *PrimaryContext) GetRuleContext() antlr.RuleContext {}

func (s *PrimaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

type CreateListContext

func NewCreateListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateListContext {}

func (s *CreateListContext) GetOp() antlr.Token {}

func (s *CreateListContext) SetOp(v antlr.Token) {}

func (s *CreateListContext) GetElems() IListInitContext {}

func (s *CreateListContext) SetElems(v IListInitContext) {}

func (s *CreateListContext) GetRuleContext() antlr.RuleContext {}

func (s *CreateListContext) RPRACKET() antlr.TerminalNode {}

func (s *CreateListContext) LBRACKET() antlr.TerminalNode {}

func (s *CreateListContext) COMMA() antlr.TerminalNode {}

func (s *CreateListContext) ListInit() IListInitContext {}

func (s *CreateListContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *CreateListContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *CreateListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type CreateStructContext

func NewCreateStructContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateStructContext {}

func (s *CreateStructContext) GetOp() antlr.Token {}

func (s *CreateStructContext) SetOp(v antlr.Token) {}

func (s *CreateStructContext) GetEntries() IMapInitializerListContext {}

func (s *CreateStructContext) SetEntries(v IMapInitializerListContext) {}

func (s *CreateStructContext) GetRuleContext() antlr.RuleContext {}

func (s *CreateStructContext) RBRACE() antlr.TerminalNode {}

func (s *CreateStructContext) LBRACE() antlr.TerminalNode {}

func (s *CreateStructContext) COMMA() antlr.TerminalNode {}

func (s *CreateStructContext) MapInitializerList() IMapInitializerListContext {}

func (s *CreateStructContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *CreateStructContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *CreateStructContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type ConstantLiteralContext

func NewConstantLiteralContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantLiteralContext {}

func (s *ConstantLiteralContext) GetRuleContext() antlr.RuleContext {}

func (s *ConstantLiteralContext) Literal() ILiteralContext {}

func (s *ConstantLiteralContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ConstantLiteralContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ConstantLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type NestedContext

func NewNestedContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NestedContext {}

func (s *NestedContext) GetE() IExprContext {}

func (s *NestedContext) SetE(v IExprContext) {}

func (s *NestedContext) GetRuleContext() antlr.RuleContext {}

func (s *NestedContext) LPAREN() antlr.TerminalNode {}

func (s *NestedContext) RPAREN() antlr.TerminalNode {}

func (s *NestedContext) Expr() IExprContext {}

func (s *NestedContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *NestedContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *NestedContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type CreateMessageContext

func NewCreateMessageContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateMessageContext {}

func (s *CreateMessageContext) GetLeadingDot() antlr.Token {}

func (s *CreateMessageContext) Get_IDENTIFIER() antlr.Token {}

func (s *CreateMessageContext) GetS16() antlr.Token {}

func (s *CreateMessageContext) GetOp() antlr.Token {}

func (s *CreateMessageContext) SetLeadingDot(v antlr.Token) {}

func (s *CreateMessageContext) Set_IDENTIFIER(v antlr.Token) {}

func (s *CreateMessageContext) SetS16(v antlr.Token) {}

func (s *CreateMessageContext) SetOp(v antlr.Token) {}

func (s *CreateMessageContext) GetIds() []antlr.Token {}

func (s *CreateMessageContext) GetOps() []antlr.Token {}

func (s *CreateMessageContext) SetIds(v []antlr.Token) {}

func (s *CreateMessageContext) SetOps(v []antlr.Token) {}

func (s *CreateMessageContext) GetEntries() IFieldInitializerListContext {}

func (s *CreateMessageContext) SetEntries(v IFieldInitializerListContext) {}

func (s *CreateMessageContext) GetRuleContext() antlr.RuleContext {}

func (s *CreateMessageContext) RBRACE() antlr.TerminalNode {}

func (s *CreateMessageContext) AllIDENTIFIER() []antlr.TerminalNode {}

func (s *CreateMessageContext) IDENTIFIER(i int) antlr.TerminalNode {}

func (s *CreateMessageContext) LBRACE() antlr.TerminalNode {}

func (s *CreateMessageContext) COMMA() antlr.TerminalNode {}

func (s *CreateMessageContext) AllDOT() []antlr.TerminalNode {}

func (s *CreateMessageContext) DOT(i int) antlr.TerminalNode {}

func (s *CreateMessageContext) FieldInitializerList() IFieldInitializerListContext {}

func (s *CreateMessageContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *CreateMessageContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *CreateMessageContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type IdentOrGlobalCallContext

func NewIdentOrGlobalCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IdentOrGlobalCallContext {}

func (s *IdentOrGlobalCallContext) GetLeadingDot() antlr.Token {}

func (s *IdentOrGlobalCallContext) GetId() antlr.Token {}

func (s *IdentOrGlobalCallContext) GetOp() antlr.Token {}

func (s *IdentOrGlobalCallContext) SetLeadingDot(v antlr.Token) {}

func (s *IdentOrGlobalCallContext) SetId(v antlr.Token) {}

func (s *IdentOrGlobalCallContext) SetOp(v antlr.Token) {}

func (s *IdentOrGlobalCallContext) GetArgs() IExprListContext {}

func (s *IdentOrGlobalCallContext) SetArgs(v IExprListContext) {}

func (s *IdentOrGlobalCallContext) GetRuleContext() antlr.RuleContext {}

func (s *IdentOrGlobalCallContext) IDENTIFIER() antlr.TerminalNode {}

func (s *IdentOrGlobalCallContext) RPAREN() antlr.TerminalNode {}

func (s *IdentOrGlobalCallContext) DOT() antlr.TerminalNode {}

func (s *IdentOrGlobalCallContext) LPAREN() antlr.TerminalNode {}

func (s *IdentOrGlobalCallContext) ExprList() IExprListContext {}

func (s *IdentOrGlobalCallContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *IdentOrGlobalCallContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *IdentOrGlobalCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Primary() (localctx IPrimaryContext) {}

type IExprListContext

type ExprListContext

func NewEmptyExprListContext() *ExprListContext {}

func InitEmptyExprListContext(p *ExprListContext)  {}

func (*ExprListContext) IsExprListContext() {}

func NewExprListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprListContext {}

func (s *ExprListContext) GetParser() antlr.Parser {}

func (s *ExprListContext) Get_expr() IExprContext {}

func (s *ExprListContext) Set_expr(v IExprContext) {}

func (s *ExprListContext) GetE() []IExprContext {}

func (s *ExprListContext) SetE(v []IExprContext) {}

func (s *ExprListContext) AllExpr() []IExprContext {}

func (s *ExprListContext) Expr(i int) IExprContext {}

func (s *ExprListContext) AllCOMMA() []antlr.TerminalNode {}

func (s *ExprListContext) COMMA(i int) antlr.TerminalNode {}

func (s *ExprListContext) GetRuleContext() antlr.RuleContext {}

func (s *ExprListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *ExprListContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ExprListContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ExprListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) ExprList() (localctx IExprListContext) {}

type IListInitContext

type ListInitContext

func NewEmptyListInitContext() *ListInitContext {}

func InitEmptyListInitContext(p *ListInitContext)  {}

func (*ListInitContext) IsListInitContext() {}

func NewListInitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListInitContext {}

func (s *ListInitContext) GetParser() antlr.Parser {}

func (s *ListInitContext) Get_optExpr() IOptExprContext {}

func (s *ListInitContext) Set_optExpr(v IOptExprContext) {}

func (s *ListInitContext) GetElems() []IOptExprContext {}

func (s *ListInitContext) SetElems(v []IOptExprContext) {}

func (s *ListInitContext) AllOptExpr() []IOptExprContext {}

func (s *ListInitContext) OptExpr(i int) IOptExprContext {}

func (s *ListInitContext) AllCOMMA() []antlr.TerminalNode {}

func (s *ListInitContext) COMMA(i int) antlr.TerminalNode {}

func (s *ListInitContext) GetRuleContext() antlr.RuleContext {}

func (s *ListInitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *ListInitContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *ListInitContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *ListInitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) ListInit() (localctx IListInitContext) {}

type IFieldInitializerListContext

type FieldInitializerListContext

func NewEmptyFieldInitializerListContext() *FieldInitializerListContext {}

func InitEmptyFieldInitializerListContext(p *FieldInitializerListContext)  {}

func (*FieldInitializerListContext) IsFieldInitializerListContext() {}

func NewFieldInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FieldInitializerListContext {}

func (s *FieldInitializerListContext) GetParser() antlr.Parser {}

func (s *FieldInitializerListContext) GetS21() antlr.Token {}

func (s *FieldInitializerListContext) SetS21(v antlr.Token) {}

func (s *FieldInitializerListContext) GetCols() []antlr.Token {}

func (s *FieldInitializerListContext) SetCols(v []antlr.Token) {}

func (s *FieldInitializerListContext) Get_optField() IOptFieldContext {}

func (s *FieldInitializerListContext) Get_expr() IExprContext {}

func (s *FieldInitializerListContext) Set_optField(v IOptFieldContext) {}

func (s *FieldInitializerListContext) Set_expr(v IExprContext) {}

func (s *FieldInitializerListContext) GetFields() []IOptFieldContext {}

func (s *FieldInitializerListContext) GetValues() []IExprContext {}

func (s *FieldInitializerListContext) SetFields(v []IOptFieldContext) {}

func (s *FieldInitializerListContext) SetValues(v []IExprContext) {}

func (s *FieldInitializerListContext) AllOptField() []IOptFieldContext {}

func (s *FieldInitializerListContext) OptField(i int) IOptFieldContext {}

func (s *FieldInitializerListContext) AllCOLON() []antlr.TerminalNode {}

func (s *FieldInitializerListContext) COLON(i int) antlr.TerminalNode {}

func (s *FieldInitializerListContext) AllExpr() []IExprContext {}

func (s *FieldInitializerListContext) Expr(i int) IExprContext {}

func (s *FieldInitializerListContext) AllCOMMA() []antlr.TerminalNode {}

func (s *FieldInitializerListContext) COMMA(i int) antlr.TerminalNode {}

func (s *FieldInitializerListContext) GetRuleContext() antlr.RuleContext {}

func (s *FieldInitializerListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *FieldInitializerListContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *FieldInitializerListContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *FieldInitializerListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) FieldInitializerList() (localctx IFieldInitializerListContext) {}

type IOptFieldContext

type OptFieldContext

func NewEmptyOptFieldContext() *OptFieldContext {}

func InitEmptyOptFieldContext(p *OptFieldContext)  {}

func (*OptFieldContext) IsOptFieldContext() {}

func NewOptFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptFieldContext {}

func (s *OptFieldContext) GetParser() antlr.Parser {}

func (s *OptFieldContext) GetOpt() antlr.Token {}

func (s *OptFieldContext) SetOpt(v antlr.Token) {}

func (s *OptFieldContext) IDENTIFIER() antlr.TerminalNode {}

func (s *OptFieldContext) QUESTIONMARK() antlr.TerminalNode {}

func (s *OptFieldContext) GetRuleContext() antlr.RuleContext {}

func (s *OptFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *OptFieldContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *OptFieldContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *OptFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) OptField() (localctx IOptFieldContext) {}

type IMapInitializerListContext

type MapInitializerListContext

func NewEmptyMapInitializerListContext() *MapInitializerListContext {}

func InitEmptyMapInitializerListContext(p *MapInitializerListContext)  {}

func (*MapInitializerListContext) IsMapInitializerListContext() {}

func NewMapInitializerListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MapInitializerListContext {}

func (s *MapInitializerListContext) GetParser() antlr.Parser {}

func (s *MapInitializerListContext) GetS21() antlr.Token {}

func (s *MapInitializerListContext) SetS21(v antlr.Token) {}

func (s *MapInitializerListContext) GetCols() []antlr.Token {}

func (s *MapInitializerListContext) SetCols(v []antlr.Token) {}

func (s *MapInitializerListContext) Get_optExpr() IOptExprContext {}

func (s *MapInitializerListContext) Get_expr() IExprContext {}

func (s *MapInitializerListContext) Set_optExpr(v IOptExprContext) {}

func (s *MapInitializerListContext) Set_expr(v IExprContext) {}

func (s *MapInitializerListContext) GetKeys() []IOptExprContext {}

func (s *MapInitializerListContext) GetValues() []IExprContext {}

func (s *MapInitializerListContext) SetKeys(v []IOptExprContext) {}

func (s *MapInitializerListContext) SetValues(v []IExprContext) {}

func (s *MapInitializerListContext) AllOptExpr() []IOptExprContext {}

func (s *MapInitializerListContext) OptExpr(i int) IOptExprContext {}

func (s *MapInitializerListContext) AllCOLON() []antlr.TerminalNode {}

func (s *MapInitializerListContext) COLON(i int) antlr.TerminalNode {}

func (s *MapInitializerListContext) AllExpr() []IExprContext {}

func (s *MapInitializerListContext) Expr(i int) IExprContext {}

func (s *MapInitializerListContext) AllCOMMA() []antlr.TerminalNode {}

func (s *MapInitializerListContext) COMMA(i int) antlr.TerminalNode {}

func (s *MapInitializerListContext) GetRuleContext() antlr.RuleContext {}

func (s *MapInitializerListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *MapInitializerListContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *MapInitializerListContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *MapInitializerListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) MapInitializerList() (localctx IMapInitializerListContext) {}

type IOptExprContext

type OptExprContext

func NewEmptyOptExprContext() *OptExprContext {}

func InitEmptyOptExprContext(p *OptExprContext)  {}

func (*OptExprContext) IsOptExprContext() {}

func NewOptExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptExprContext {}

func (s *OptExprContext) GetParser() antlr.Parser {}

func (s *OptExprContext) GetOpt() antlr.Token {}

func (s *OptExprContext) SetOpt(v antlr.Token) {}

func (s *OptExprContext) GetE() IExprContext {}

func (s *OptExprContext) SetE(v IExprContext) {}

func (s *OptExprContext) Expr() IExprContext {}

func (s *OptExprContext) QUESTIONMARK() antlr.TerminalNode {}

func (s *OptExprContext) GetRuleContext() antlr.RuleContext {}

func (s *OptExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

func (s *OptExprContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *OptExprContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *OptExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) OptExpr() (localctx IOptExprContext) {}

type ILiteralContext

type LiteralContext

func NewEmptyLiteralContext() *LiteralContext {}

func InitEmptyLiteralContext(p *LiteralContext)  {}

func (*LiteralContext) IsLiteralContext() {}

func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext {}

func (s *LiteralContext) GetParser() antlr.Parser {}

func (s *LiteralContext) CopyAll(ctx *LiteralContext) {}

func (s *LiteralContext) GetRuleContext() antlr.RuleContext {}

func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {}

type BytesContext

func NewBytesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BytesContext {}

func (s *BytesContext) GetTok() antlr.Token {}

func (s *BytesContext) SetTok(v antlr.Token) {}

func (s *BytesContext) GetRuleContext() antlr.RuleContext {}

func (s *BytesContext) BYTES() antlr.TerminalNode {}

func (s *BytesContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *BytesContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *BytesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type UintContext

func NewUintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *UintContext {}

func (s *UintContext) GetTok() antlr.Token {}

func (s *UintContext) SetTok(v antlr.Token) {}

func (s *UintContext) GetRuleContext() antlr.RuleContext {}

func (s *UintContext) NUM_UINT() antlr.TerminalNode {}

func (s *UintContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *UintContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *UintContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type NullContext

func NewNullContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullContext {}

func (s *NullContext) GetTok() antlr.Token {}

func (s *NullContext) SetTok(v antlr.Token) {}

func (s *NullContext) GetRuleContext() antlr.RuleContext {}

func (s *NullContext) NUL() antlr.TerminalNode {}

func (s *NullContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *NullContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *NullContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type BoolFalseContext

func NewBoolFalseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolFalseContext {}

func (s *BoolFalseContext) GetTok() antlr.Token {}

func (s *BoolFalseContext) SetTok(v antlr.Token) {}

func (s *BoolFalseContext) GetRuleContext() antlr.RuleContext {}

func (s *BoolFalseContext) CEL_FALSE() antlr.TerminalNode {}

func (s *BoolFalseContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *BoolFalseContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *BoolFalseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type StringContext

func NewStringContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringContext {}

func (s *StringContext) GetTok() antlr.Token {}

func (s *StringContext) SetTok(v antlr.Token) {}

func (s *StringContext) GetRuleContext() antlr.RuleContext {}

func (s *StringContext) STRING() antlr.TerminalNode {}

func (s *StringContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *StringContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type DoubleContext

func NewDoubleContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DoubleContext {}

func (s *DoubleContext) GetSign() antlr.Token {}

func (s *DoubleContext) GetTok() antlr.Token {}

func (s *DoubleContext) SetSign(v antlr.Token) {}

func (s *DoubleContext) SetTok(v antlr.Token) {}

func (s *DoubleContext) GetRuleContext() antlr.RuleContext {}

func (s *DoubleContext) NUM_FLOAT() antlr.TerminalNode {}

func (s *DoubleContext) MINUS() antlr.TerminalNode {}

func (s *DoubleContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *DoubleContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *DoubleContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type BoolTrueContext

func NewBoolTrueContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BoolTrueContext {}

func (s *BoolTrueContext) GetTok() antlr.Token {}

func (s *BoolTrueContext) SetTok(v antlr.Token) {}

func (s *BoolTrueContext) GetRuleContext() antlr.RuleContext {}

func (s *BoolTrueContext) CEL_TRUE() antlr.TerminalNode {}

func (s *BoolTrueContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *BoolTrueContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *BoolTrueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

type IntContext

func NewIntContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IntContext {}

func (s *IntContext) GetSign() antlr.Token {}

func (s *IntContext) GetTok() antlr.Token {}

func (s *IntContext) SetSign(v antlr.Token) {}

func (s *IntContext) SetTok(v antlr.Token) {}

func (s *IntContext) GetRuleContext() antlr.RuleContext {}

func (s *IntContext) NUM_INT() antlr.TerminalNode {}

func (s *IntContext) MINUS() antlr.TerminalNode {}

func (s *IntContext) EnterRule(listener antlr.ParseTreeListener) {}

func (s *IntContext) ExitRule(listener antlr.ParseTreeListener) {}

func (s *IntContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (p *CELParser) Literal() (localctx ILiteralContext) {}

func (p *CELParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool {}

func (p *CELParser) Relation_Sempred(localctx antlr.RuleContext, predIndex int) bool {}

func (p *CELParser) Calc_Sempred(localctx antlr.RuleContext, predIndex int) bool {}

func (p *CELParser) Member_Sempred(localctx antlr.RuleContext, predIndex int) bool {}