Object is of type 'unknown' typescript generics

Since this is the first result you get when you google Object is of type 'unknown', I want to post my case. It might help future readers. This is not the answer to OP's question.

I got this error in the catch block. After debugging for a while I came to know that starting typescript v4.0, catch clause variables have type unknown instead of any.

And according to docs:

unknown is safer than any because it reminds us that we need to perform some sort of type-checks before operating on our values.

My code looked something like this before v4.0:

try {
  // try something exceptional here
} catch (error) {
  console.log(error.message);
}

And to fix this error, I had to put an additional if check on error variable.

try {
  // try something exceptional here
} catch (error) {
  let errorMessage = "Failed to do something exceptional";
  if (error instanceof Error) {
    errorMessage = error.message;
  }
  console.log(errorMessage);
}

updating my tsconfig.json with the following has worked for me:

"useUnknownInCatchVariables": false,

Update:

you need to put it like this under compilerOptions

"compilerOptions": {
    "useUnknownInCatchVariables": false
  }

Note: You need Typescript v4.4 or higher to be able to use this compiler option else you get a compiler error.

npm install -g ts-node@latest

npm install -g typescript@latest

I got this issue in a try/catch bumping the Typescript to version 4.4 and found in the documentation the explanation for that.

In resume they added the flag useUnknownInCatchVariables that is true by default if strict. It basically changes the type of the error in a catch from any to unknown causing this issue.

So in order to bump to 4.4 you have some options:

try {
    ...
} catch(e) {
    console.log((e as Error).message)
}

or:

try {
    ...
} catch(e) {
    if (e instanceof Error) {
        console.log(e.message)
    }
}

or in your tsconfig.json you can explicitly set the flag to false:

{
    "compilerOptions": {
        "strict": true,
        "useUnknownInCatchVariables": false
    }
}

You can use casting: (err as Error)

I like the if statement solution, but this also works:

catch (error) {
  let msg = (error as Error).message;
}

Issue with TS 4.0 explained here: https://devblogs.microsoft.com/typescript/announcing-typescript-4-0/#unknown-on-catch

All of the other answers didn't work for me but using the isAxiosError worked just fine:

   } catch (error) {
      if (axios.isAxiosError(error)) {
        const errResp = error.response;
        // Handle your error type safe here
      } else {
        // Handle the unknown
      }
    }

No Object is of type 'unknown'.ts(2571) error anymore.

Create an interface for options or use any as type,

makeFunction((param, options: any) => {

  const a = options.optionsValue;

  })({optionsValue: 'some value'});

Typescript takes options type as {} which causes issue during compilation.

Add a type to the calling function like this:

function(): Observable<any>

to avoid it from returnig unknown.

You have 2 options:

• Verify the type by doing

try {
 
} catch (error) {
  if (error instanceof Error) {
    console.error(error.message);
  } else {
    console.error('An unknown error occurred');
  }
}

• Force the error

try {
} catch (error) {
  const err = error as Error;
  console.error(err.message);
}

This I have used, this will allow you to do gridObj., custom properties

let gridobj : any = this.$refs.grid;
gridobj.columns(col, "add");

I stumbled on this while coding in Angular, and it occurs within the *ngFor loop using the keyvalue pipe. In such loops, if the value is an object, TypeScript needs to know the type of the key and the value. So when initializing the object you're going to be iterating through using *ngFor, be certain to precise what type is expected of the key and what type is expected of the value, like so:

some_object: {[key: number]: string} = {2: 'foo', 1: 'bar'};

I took such as error while useState. I describe for error usestate:

'''`const[error, setError]=useState(String);`

and as for that catch block

catch (ex) {
        let erMssg = "exceptional";
        if (ex instanceof Error) {
            erMssg  = ex.message;
          }
        setError(erMssg );
        setLoading(false);
    }

simply put "any" after the catch error message, it should work.

`try {

} catch (error: any) {

console.log(error.message); }`