Here is an example of how I am using decode with TypeScript

import jwt from 'jsonwebtoken';

export const isTokenExpired = (token: string): boolean => {
    try {
        const { exp } = jwt.decode(token) as {
            exp: number;
        };
        const expirationDatetimeInSeconds = exp * 1000;

        return Date.now() >= expirationDatetimeInSeconds;
    } catch {
        return true;
    }
};

Although not necessary, here is another piece of code for your reference

import 'jest';
import jwt from 'jsonwebtoken';

import { isTokenExpired } from 'path-to-isTokenExpired/isTokenExpired';

describe('isTokenExpired', () => {
    it('should return true if jwt token expired', () => {
        const currentTimeInSecondsMinusThirtySeconds = Math.floor(Date.now() / 1000) - 30;
        const expiredToken = jwt.sign({ foo: 'bar', exp: currentTimeInSecondsMinusThirtySeconds }, 'shhhhh');

        expect(isTokenExpired(expiredToken)).toEqual(true);
    });

    it('should return false if jwt token not expired', () => {
        const currentTimeInSecondsPlusThirtySeconds = Math.floor(Date.now() / 1000) + 30;
        const notExpiredToken = jwt.sign({ foo: 'bar', exp: currentTimeInSecondsPlusThirtySeconds }, 'shhhhh');

        expect(isTokenExpired(notExpiredToken)).toEqual(false);
    });

    it('should return true if jwt token invalid', () => {
        expect(isTokenExpired('invalidtoken')).toEqual(true);
    });
});

I discovered a method for importing users:

import { sign, verify } from 'jsonwebtoken';
sign('Hello', 'secret');

Personally, I believe using the require method is more efficient as it eliminates the need to import each individual function separately.

Encountered a similar error message while using the line import jwt from 'jsonwebtoken'. However, switching to

var jwt = require('jsonwebtoken');

var jwt = require('jsonwebtoken');
var tokenBase64 = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiZXhwIjoiMTUxMTk1MDcwMyIsImFkbWluIjp0cnVlfQ.wFC-9ZsqA9QuvLkRSkQmVYpUmgH9R-j8M4D0GECuPHY';

const token = jwt.decode(tokenBase64);
const tokenExpirationDate = token.exp
console.log(tokenExpirationDate);

[2] reference: https://github.com/auth0/node-jsonwebtoken

When using jsonwebtoken version 8.3, the function jsonwebtoken.decode() now has specific type definitions:

export function decode(
    token: string,
    options?: DecodeOptions,
): null | { [key: string]: any } | string;

Given that Typescript may not always determine the correct type and the value of exp is unknown, a simple solution is to cast the result as any.

import jwt from 'jsonwebtoken'

const tokenBase64 = 'ey...' /* some valid token */

const token: any = jwt.decode(tokenBase64)
const tokenExpirationDate = token.exp

In my opinion, using

import * as jwt from 'jsonwebtoken';

import * as jwt from 'jsonwebtoken'

const { token } = request.headers
const secretCode = token.replace('Bearer ', '')
const decodedToken = jwt.verify(secretCode, 'APP_SECRET')
const userID = (decodedToken as any).userID

Feel free to specify the type of decodedToken based on how you are using the token instead of using any

When using jwt.verify and jwt.decode, the return type is typically 'string | object'.

If you have additional information regarding the return type that Typescript does not account for, you can specify it like this:

const token = jwt.decode(tokenBase64) as {exp: number}
const tokenExpirationDate = token.exp

You are free to include any other values in the object as needed.

While it can be assumed that 'exp' will be present, keep in mind that other keys may not be included in the decoded token. Verify that the token being decoded actually contains them or make them optional in your type definition: ({exp: number; random?: string})

After encountering the need for it, I created a helper function (implemented using a class-based approach - but can also function as a standalone method):

import { JwtPayload, verify } from "jsonwebtoken";

export class BaseController {
  // ...
  static decodeJWT = <T extends { [key: string]: any }>(token: string) => {
    return verify(token, process.env.JWT_ACCESS_TOKEN!) as JwtPayload & T; 
    // By applying this typing, we maintain both our encoded data and the original properties of the JWT
  };
}

This is how it's utilized in controllers:

import { BaseController } from "./BaseController";

export class UserController extends BaseController {
  static getUser = async (
    // ...
  ) => {
    // obtain token
    // It's best to check if username exists before usage
    const payload = this.decodeJWT<{ username?: string }>(token); 
    // No errors will arise here, allowing us to extract all specified properties along with the original JWT properties
    const { username, exp } = payload;
    // perform actions...
  };
}

If you want to achieve this, follow these steps:

import jwt, { JwtPayload } from 'jsonwebtoken'

const tokenBase64 = 'ey...' /* valid token here */

const decodedToken = jwt.decode(tokenBase64) as JwtPayload
const expirationDate = decodedToken.exp
//                                ^^^
// decodedToken is now recognized as a JwtPayload object, allowing access to its attributes like 'exp'.