I have an error on an exhaustive check I can't explain: has no call signatures

[rolfst]

this is my Error:

 │     This expression is not callable. typescript (2349) [82, 12]
 │        Type 'NonExhaustiveError<TransportationError | ValidationError | InputArgumentError>' has no call signatures. 

this is my code:

    const fetchData = (url: URL): TE.TaskEither<TransportationError, ZakenPartnerSap> =>
      TE.tryCatch(
        () => fetch(url.toString()).then((response) => response.json()),
        () => new TransportationError(),
      );
    const parseJsonData = (jsonData: any): E.Either<ValidationError, ZakenPartnerSap> =>
      E.tryCatch(
        () => schema.parse(jsonData),
        (e: Error) => {
          this.logger.log(e);
          return new ValidationError();
        },
      );

    const url = pipe(
      this.assembleQueryParams(zakenPartnerId, zakenPartnerKvk),
      O.map(this.assembleUrl),
      TE.fromOption(() => new InputArgumentError()),
    );

    return pipe(
      TE.Do,
      TE.bindW('url', () => url), // TaskEither<InputArgumentError, URL>
      TE.bindW('jsonData', ({ url }) => fetchData(url)), // TaskEither<TransportationError, unknown>
      TE.bindW('parsedData', ({ jsonData }) => TE.fromEither(parseJsonData(jsonData))),  // TaskEither<VallidationError, BusinessPartner>
      TE.map(({ parsedData }) => parsedData),
      TE.mapLeft((e: ValidationError | InputArgumentError | TransportationError) =>
        match(e)
          .returnType<Error>()
          .with({ _type: 'ValidationError' }, () => new Error('validation Error'))
          .with({ _type: 'InputArgurmentError' }, () => new Error('InputArgument Error'))
          .with({ _type: 'TransportationError' }, () => new Error('Transportation Error'))
          .exhaustive(), // this expression is not callable 
      ),
    )();
  }

what can I do to fix this?

[gvergnaud]

Make sure _type on your custom error is declared as string literal (you can use as const for example)

import {match} from 'ts-pattern'

class ErrorA extends Error {
  _type = "A" as const
}
class ErrorB extends Error {
  _type = "B" as const
}
class ErrorC extends Error {
  _type = "C" as const
}

const input = new ErrorA as ErrorA | ErrorB | ErrorC

const res = match(input)
  .with({_type: 'A' }, () => {})
  .with({_type: 'B' }, () => {})
  .with({_type: 'C' }, () => {})
  .exhaustive() // ✅ works

Playground