How to use the grpc.status function in grpc

private shouldAttemptReconnect(status: grpc.StatusObject): boolean {
    switch (status.code) {
      case grpc.status.UNKNOWN: // stream disconnected
      case grpc.status.UNAVAILABLE: // stream could not be established
        return true;
      default:
        return false;
    }
  }

engineRef.getRootResource(req, (err: grpc.ServiceError, resp: any) => {
            // Back-compat case - if the engine we're speaking to isn't aware that it can save and load root resources,
            // fall back to the old behavior.
            if (err && err.code === grpc.status.UNIMPLEMENTED) {
                if (rootResource) {
                    rootResource.then(resolve);
                    return;
                }

                resolve(undefined);
            }

            if (err) {
                return reject(err);
            }

            const urn = resp.getUrn();
            if (urn) {
                return resolve(urn);
            }

function isUnauthenticatedError(err) {
    var ec = errorCode(err);
    return ec.valid && (ec.code === grpc.status.UNAUTHENTICATED);
}
exports.isUnauthenticatedError = isUnauthenticatedError;

import * as httpStatus from 'http-status';
import * as grpc from 'grpc';

export class MicroChassisError extends Error {
  public readonly status?: number = httpStatus.INTERNAL_SERVER_ERROR;
  public readonly grpcCode: number = grpc.status.INTERNAL;

  get content(): string {
    return this.message;
  }
}

export class NotFoundError extends MicroChassisError {
  public readonly status = httpStatus.NOT_FOUND;
  public readonly grpcCode = grpc.status.NOT_FOUND;
}

export class ValidationError extends MicroChassisError {
  public readonly status = httpStatus.BAD_REQUEST;
  public readonly grpcCode = grpc.status.FAILED_PRECONDITION;
}

export class UnauthorizedError extends MicroChassisError {
  public readonly status = httpStatus.UNAUTHORIZED;
  public readonly grpcCode = grpc.status.UNAUTHENTICATED;
}

export class ForbiddenError extends MicroChassisError {
  public readonly status = httpStatus.FORBIDDEN;
  public readonly grpcCode = grpc.status.UNAUTHENTICATED;
}

import grpc from "grpc";

import Auth from "./auth";
import { GoogleAdsFailure, GoogleAdsError, ErrorCode } from "./types";
import {
  formatCallResults,
  getErrorLocationPath,
  isMutationRequest,
  safeguardMutationProtobufRequest,
} from "./utils";

const FAILURE_KEY = "google.ads.googleads.v2.errors.googleadsfailure-bin";
const REQUEST_ID_KEY = "request-id";
const RETRY_STATUS_CODES = [grpc.status.INTERNAL, grpc.status.RESOURCE_EXHAUSTED];

type NextCall = (options: grpc.CallOptions) => grpc.InterceptingCall | null;
export type InterceptorMethod = (options: grpc.CallOptions, nextCall: NextCall) => any;

export class MetadataInterceptor {
  private developer_token: string;
  private login_customer_id: string | undefined;
  private access_token: string | undefined;
  private auth: Auth | undefined;
  private requestInterceptor: grpc.Requester;

  constructor(
    developer_token: string,
    login_customer_id: string | undefined,
    access_token: string | undefined,
    auth: Auth | undefined

get: function(call, callback) {
        for (var i = 0; i < books.length; i++)
            if (books[i].id == call.request.id)
                return callback(null, books[i]);
        callback({
            code: grpc.status.NOT_FOUND,
            details: 'Not found'
        });
    },
    delete: function(call, callback) {

function isConflictError(err) {
    var ec = errorCode(err);
    return ec.valid && (ec.code === grpc.status.ABORTED || ec.code === grpc.status.FAILED_PRECONDITION);
}
exports.isConflictError = isConflictError;

get(call) {
    const personFound = people.find((element) => {
      return element.id === call.request.id;
    });

    if (personFound) {
      return Promise.resolve(personFound);
    }

    Promise.reject({
      'code': grpc.status.NOT_FOUND,
      'details': 'Not found',
    });
  }

delete: function(call, callback) {
        for (var i = 0; i < books.length; i++) {
            if (books[i].id == call.request.id) {
                books.splice(i, 1);
                return callback(null, {});
            }
        }
        callback({
            code: grpc.status.NOT_FOUND,
            details: 'Not found'
        });
    },
    watch: function(stream) {

private static requestToStatus(
    request:
      | showcaseV1Beta1.EchoRequest
      | showcaseV1Beta1.ExpandRequest
      | showcaseV1Beta1.WaitRequest
  ): google.rpc.Status {
    const message =
      request.error && request.error.message ? request.error.message : 'Error';
    const code =
      request.error && request.error.code
        ? request.error.code
        : grpc.status.INVALID_ARGUMENT;
    const details =
      request.error && request.error.details ? request.error.details : [];
    const error = new google.rpc.Status();
    error.code = code;
    error.message = message;
    error.details = details;
    return error;
  }