How to use the messaging-api-common.snakecaseKeysDeep function in messaging-api-common

options: { quickReplies?: Types.QuickReply[] } = {}
): FormData {
  const message: Types.FileDataMediaAttachmentMessage = {
    ...payload,
  };

  // snakecase support for backward compatibility
  const quickReplies = options.quickReplies || (options as any).quick_replies;

  if (quickReplies && Array.isArray(quickReplies) && quickReplies.length >= 1) {
    message.quickReplies = quickReplies;
  }

  const formdata = new FormData();

  formdata.append('message', JSON.stringify(snakecaseKeysDeep(message)));
  formdata.append(
    'filedata',
    filedata,
    // FIXME: use pick for formdata options
    omit(options, ['quickReplies'])
  );

  return formdata;
}

async callMethod(
    method: Types.AvailableMethod,
    inputBody: Record = {}
  ): Promise {
    try {
      const body = {
        ...omit(inputBody, ['token', 'accessToken']),
        token: inputBody.accessToken || inputBody.token || this._token,
      };

      const response = await this._axios.post(
        method,
        querystring.stringify(snakecaseKeysDeep(body) as any)
      );

      const data = (camelcaseKeysDeep(
        response.data
      ) as any) as Types.OAuthAPIResponse;

      if (!data.ok) {
        const { config, request } = response;

        throw new AxiosError(`Slack API - ${data.error}`, {
          config,
          request,
          response,
        });
      }

const recipient =
      typeof psidOrRecipient === 'string'
        ? {
            id: psidOrRecipient,
          }
        : psidOrRecipient;

    let messagingType = 'UPDATE';
    if (options.messagingType) {
      messagingType = options.messagingType;
    } else if (options.tag) {
      messagingType = 'MESSAGE_TAG';
    }

    formdata.append('messaging_type', messagingType);
    formdata.append('recipient', JSON.stringify(snakecaseKeysDeep(recipient)));

    return this._axios
      .post(
        `/me/messages?access_token=${options.accessToken || this._accessToken}`,
        formdata,
        {
          headers: formdata.getHeaders(),
        }
      )
      .then(res => res.data, handleError);
  }

.map(item => {
        if (item.body) {
          const body = snakecaseKeysDeep(item.body) as Record;
          return {
            ...item,
            body: Object.keys(body)
              .map(key => {
                const val = body[key];
                return `${encodeURIComponent(key)}=${encodeURIComponent(
                  typeof val === 'object' ? JSON.stringify(val) : val
                )}`;
              })
              .join('&'),
          };
        }
        return item;
      });

(data: any) =>
          data && isPlainObject(data) ? snakecaseKeysDeep(data) : data,
        ...(axios.defaults.transformRequest as AxiosTransformer[]),

sendRawBody(
    body: Record
  ): Promise {
    return this._axios.post('', snakecaseKeysDeep(body)).then(res => res.data);
  }