type Parser … // NewParser creates a new Parser with the specified options func NewParser(options ...ParserOption) *Parser { … } // Parse parses, validates, verifies the signature and returns the parsed token. // keyFunc will receive the parsed token and should return the key for validating. func (p *Parser) Parse(tokenString string, keyFunc Keyfunc) (*Token, error) { … } // ParseWithClaims parses, validates, and verifies like Parse, but supplies a default object implementing the Claims // interface. This provides default values which can be overridden and allows a caller to use their own type, rather // than the default MapClaims implementation of Claims. // // Note: If you provide a custom claim implementation that embeds one of the standard claims (such as RegisteredClaims), // make sure that a) you either embed a non-pointer version of the claims or b) if you are using a pointer, allocate the // proper memory for it before passing in the overall claims, otherwise you might run into a panic. func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) { … } // ParseUnverified parses the token but doesn't validate the signature. // // WARNING: Don't use this method unless you know what you're doing. // // It's only ever useful in cases where you know the signature is valid (because it has // been checked previously in the stack) and you want to extract values from it. func (p *Parser) ParseUnverified(tokenString string, claims Claims) (token *Token, parts []string, err error) { … }