class ExampleApiUnkownError extends Error { ... }
class ExampleApiError extends Error { ... }

const BaseResponse = z.object({
  response: z.custom((value) => value !== undefined)
})

type BaseResponse = z.static<typeof BaseResponse>; 

const ErrorResponse = z.object({
  error: z.object({ ... })
})

class ExampleApiClient {
  async request({...}): Either<ExampleApiError | ExampleApiUnknownError, BaseResponse> {
    try {
      const response = await fetch(...);
      const json = await response.json();
      
      // And here i would like to 
      // 1. Check if json matches BaseResponse -> return early
      // 2. Check if json matches ErrorResponse -> make ExampleApiError from it and return early
      // 3. return left(new ExampleApiUnkownError("...", { cause: { response, json } })); if nothing matched
      
      // In my opinion, both .parse and .safeParse are too cumbersome, cause
      // .parse requires error handling
      // .safeParse requires additional variable to work correctly
      
      // I prefer doing something like this
      
      if (BaseResponse.guard(json)) {
        return right(json.response);
      }
      
      if(ErrorResponse.guard(json)) {
        return left(ExampleApiError.fromJSON(json));
      }
      
      return left(new ExampleApiUnkownError("...", { response, json }));
      
    } catch(error) {
      return left(new ExampleApiUnkownError("...", { cause: error }));
    }    
  }
}