How to use the boom function in boom

export const transformError = (err: Error & { statusCode?: number }) => {
  if (Boom.isBoom(err)) {
    return err;
  } else {
    if (err.statusCode != null) {
      return new Boom(err.message, { statusCode: err.statusCode });
    } else if (err instanceof TypeError) {
      // allows us to throw type errors instead of booms in some conditions
      // where we don't want to mingle Boom with the rest of the code
      return new Boom(err.message, { statusCode: 400 });
    } else {
      // natively return the err and allow the regular framework
      // to deal with the error when it is a non Boom
      return err;
    }
  }
};

private toError(kibanaResponse: KibanaResponse) {
    const { payload } = kibanaResponse;
    // we use for BWC with Boom payload for error responses - {error: string, message: string, statusCode: string}
    const error = new Boom('', {
      statusCode: kibanaResponse.status,
    });

    error.output.payload.message = getErrorMessage(payload);
    error.output.payload.attributes = getErrorAttributes(payload);

    const headers = kibanaResponse.options.headers;
    if (headers) {
      // Hapi typings for header accept only strings, although string[] is a valid value
      error.output.headers = headers as any;
    }

    return error;
  }
}

export async function getResponse(url: string): Promise {
  try {
    const response = await fetch(url);
    if (response.ok) {
      return response;
    } else {
      throw new Boom(response.statusText, { statusCode: response.status });
    }
  } catch (e) {
    throw Boom.boomify(e);
  }
}

const {
                [PARAM_TEXT]: text,
                [PARAM_TIMEZONE]: timezone,
                [PARAM_SESSION]: sessionId,
                ...rest
            } = request.payload;

            const {
                [PARAM_DEBUG]: debug
            } = request.query;

            try {
                return await agentService.converse({ id: agentId, text, timezone, sessionId, debug, additionalKeys: rest });
            }
            catch ({ message, statusCode }) {
                return new Boom(message, { statusCode });
            }
        }
    }

handler: async (request) => {

            const { settingsService } = await request.services();
            const { [PARAM_NAME]: name } = request.params;
            try {
                return await settingsService.findByName({ name });
            }
            catch ({ message, statusCode }) {

                return new Boom(message, { statusCode });
            }
        }
    }

handler: async (request) => {

            const { agentService } = await request.services();
            const {
                [PARAM_AGENT_ID]: id,
                [PARAM_NAME]: name
            } = request.params;
            try {
                return await agentService.findSettingByName({ id, name });
            }
            catch ({ message, statusCode }) {
                return new Boom(message, { statusCode });
            }
        }
    }

handler: async (request) => {

                const { globalService } = await request.services();
                const {
                    [PARAM_FIELD]: field,
                    [PARAM_VALUE]: value
                } = request.params;
                try {
                    return await globalService.searchByField({ field, value, model: ROUTE_TO_MODEL[ROUTE] });
                }
                catch ({ message, statusCode }) {

                    return new Boom(message, { statusCode });
                }
            }
        }

handler: async (request) => {

            const { agentService } = await request.services();
            const { [PARAM_AGENT_ID]: id } = request.params;
            try {
                return await agentService.createPostFormat({ id, postFormatData: request.payload });
            }
            catch ({ message, statusCode }) {
                return new Boom(message, { statusCode });
            }
        }
    }

handler: async (request) => {

            const { documentService } = await request.services();

            try {
                return await documentService.create({ data: request.payload });
            }
            catch ({ message, statusCode }) {

                return new Boom(message, { statusCode });
            }
        }
    }

handler: async (request, h) => {

            const { contextService } = await request.services();
            const { [PARAM_SESSION]: sessionId, [PARAM_FRAME]: frameId } = request.params;
            try {
                await contextService.removeFramesBySessionIdAndFrameId({ sessionId, frameId });
                return h.continue;
            }
            catch ({ message, statusCode }) {

                return new Boom(message, { statusCode });
            }
        }
    }