TSのResult型について知りたい

import { findUsersIn } from 'imaginary-database'
// ^ assume findUsersIn has the following signature:
// findUsersIn(country: string): ResultAsync<Array<User>, Error>

// Let's say we need to low-level errors from findUsersIn to be more readable
const usersInCanada = findUsersIn("Canada").mapErr((error: Error) => {
  // The only error we want to pass to the user is "Unknown country"
  if(error.message === "Unknown country"){
    return error.message
  }
  // All other errors will be labelled as a system error
  return "System error, please contact an administrator."
})

// usersInCanada is of type ResultAsync<Array<User>, string>

usersInCanada.then((usersResult: Result<Array<User>, string>) => {
  if(usersResult.isErr()){
    res.status(400).json({
      error: usersResult.error
    })
  }
  else{
    res.status(200).json({
      users: usersResult.value
    })
  }
})

  async getUserById(id: number): Promise<Result<Object, RepositoryError>> {
    let res;
    try {
      res = await fetch(`${URL}/users/${id}`);
    } catch (e) {
      const error = new FetchMethodError(
        JSON.stringify({
          reason: "fail to fetch",
          url: URL,
          payload: { id },
        }),
        { cause: e }
      );
      loggingException(error);
      return createErr(error);
    }

    if (!res.ok) {
      switch (res.status) {
        case 401: {
          const error = new AuthorizationError(
            JSON.stringify({
              reason: "fail to fetch by miisng auth",
              url: URL,
              payload: { id },
              res,
            })
          );
          loggingException(error);
          return createErr(error);
        }
        default: {
          const error = new InternalError(
            JSON.stringify({
              reason: "internal server error",
              url: URL,
              payload: { id },
              res,
            })
          );
          loggingException(error);
          return createErr(error);
        }
      }
    }

    let data;
    try {
      data = await res.json();
    } catch (e) {
      const error = new ResponseParseError(
        JSON.stringify({
          reason: "fail to parse",
          url: URL,
          payload: { id },
        }),
        { cause: e }
      );
      loggingException(error);
      return createErr(error);
    }

    if (validate(data)) {
      return createOk(data);
    } else {
      const error = new ValidationError(
        JSON.stringify({
          reason: "fail to validate",
          url: URL,
          response: { data },
        })
      );
      loggingException(error);
      return createErr(error);
    }
  }

export const callApi = async <T extends TSchema>(
  path: string,
  validator: TypeCheck<T>,
  init?: RequestInit
): Promise<Result<Static<T>, RepositoryError>> => {
  let res
  try {
    res = await fetcher(path, init)
  } catch (e) {
    const error = new FetchMethodError(
      JSON.stringify({
        reason: 'failed to fetch',
        path,
      }),
      { cause: e }
    )
    return fail(error)
  }

  if (!res.ok) {
    switch (res.status) {
      case 401: {
        const error = new AuthorizationError(
          JSON.stringify({
            reason: 'failed to fetch by miisng auth',
            path,
            res,
          })
        )
        return fail(error)
      }
      default: {
        const error = new InternalError(
          JSON.stringify({
            reason: 'internal server error',
            path,
            res,
          })
        )
        return fail(error)
      }
    }
  }

  let data
  try {
    data = await res.json()
  } catch (e) {
    const error = new ResponseParseError(
      JSON.stringify({
        reason: 'failed to parse',
        path,
      }),
      { cause: e }
    )
    return fail(error)
  }

  if (!validator.Check(data)) {
    const cause = Array.from(getJobsResponseValidator.Errors(data))
    const error = new ValidationError(
      JSON.stringify({
        reason: 'failed to validate',
        path,
        response: { data },
      }),
      { cause }
    )
    return fail(error)
  }

  return succeed(data)
}

const handleDelete = async (id: string) => {
  await deleteUser(id)
}