import { APIOptions } from './APIOptions'
import { APIResponse } from './APIResponse'
import { BaseAPI } from './BaseAPI'
import { OpenAccountRequest } from './accounts/requests/OpenAccountRequest'
import { AccountResponse } from './accounts/responses/AccountResponse'
import { AssetTotalsResponse } from './accounts/responses/AssetTotalsResponse'
import { AssetTotalsRequest } from './accounts/requests/AssetTotalsRequest'
import { CashTotalsRequest } from './accounts/requests/CashTotalsRequest'
import { CashTotalsResponse } from './accounts/responses/CashTotalsResponse'
import { UploadDocumentRequest } from './kyc/requests/UploadDocumentRequest'
import { UploadDocumentResponse } from './kyc/responses/UploadDocumentResponse'
import * as FormData from 'form-data'
import { SubmitKYCDocumentCheckRequest } from './kyc/requests/SubmitKYCDocumentCheckRequest'
import { KYCDocumentCheckResponse } from './kyc/responses/KYCDocumentCheckResponse'
import { GetKYCDocumentCheckRequest } from './kyc/requests/GetKYCDocumentCheckRequest'
import { FailKYCDocumentCheckRequest } from './kyc/sandbox-only/FailKYCDocumentCheckRequest'
import { VerifyKYCDocumentCheckRequest } from './kyc/sandbox-only/VerifyKYCDocumentCheckRequest'

import {
  KYCDocumentChecksType,
  AccountsType,
  AgreementPreviewsType,
  FundsTransferMethodsType,
  ContributionsType,
  FundsTransfersType,
  ContingentHoldsType,
  DisbursementsType,
  WebhookConfigsType,
  ContactsType,
  WebhookConfigType,
} from './ResourceTypes'

import { GetAccountRequest } from './accounts/requests/GetAccountRequest'
import { GetKYCDocumentCheckResponse } from './kyc/responses/GetKYCDocumentCheckResponse'
import { GetAMLCheckRequest } from './aml/requests/GetAMLCheckRequest'
import { GetAMLCheckResponse } from './aml/responses/GetAMLCheckResponse'
import { ApproveAMLCheckRequest } from './aml/sandbox-only/ApproveAMLCheckRequest'
import { AMLCheckResponse } from './aml/responses/AMLCheckResponse'
import { DenyAMLCheckRequest } from './aml/sandbox-only/DenyAMLCheckRequest'
import { GetCIPCheckRequest } from './cip/requests/GetCIPCheckRequest'
import { GetCIPCheckResponse } from './cip/responses/GetCIPCheckResponse'
import { DenyCIPCheckRequest } from './cip/sandbox-only/DenyCIPCheckRequest'
import { CIPCheckResponse } from './cip/responses/CIPCheckResponse'
import { ApproveCIPCheckRequest } from './cip/sandbox-only/ApproveCIPCheckRequest'
import { SubmitCIPCheckForReviewRequest } from './cip/requests/SubmitCIPCheckForReviewRequest'
import { StandardQueryParams } from './StandardQueryParams'
import { GetAgreementPreviewsRequest } from './accounts/requests/GetAgreementPreviewsRequest'
import { AgreementPreviewsResponse } from './accounts/responses/AgreementPreviewsResponse'
import { GetContactRequest } from './contacts/requests/GetContactRequest'
import { ContactResponse } from './contacts/responses/ContactResponse'
import { CreateProcessorTokenFundsTransferMethodRequest } from './funds-transfers/requests/CreateProcessorTokenFundsTransferMethodRequest'
import { FundsTransferMethodResponse } from './funds-transfers/responses/FundsTransferMethodResponse'
import { DepositFundsUsingFundsTransferMethodRequest } from './funds-transfers/requests/DepositFundsUsingFundsTransferMethodRequest'
import { ContributionsResponse } from './funds-transfers/responses/ContributionsResponse'
import { SettleFundsTransferRequest } from './funds-transfers/sandbox-only/SettleFundsTransferRequest'
import { FundsTransferResponse } from './funds-transfers/responses/FundsTransferResponse'
import { ClearFundsTransferRequest } from './funds-transfers/sandbox-only/ClearFundsTransferRequest'
import { ReverseFundsTransferRequest } from './funds-transfers/sandbox-only/ReverseFundsTransferRequest'
import { Query } from './Query'
import { GetContingentHoldRequest } from './contingent-holds/requests/GetContingentHoldRequest'
import { ContingentHold } from './contingent-holds/ContingentHold'
import { ClearContingentHoldRequest } from './contingent-holds/sandbox-only/ClearContingentHoldRequest'
import { WithdrawFundsUsingFundsTransferMethodRequest } from './funds-transfers/requests/WithdrawFundsUsingFundsTransferMethodRequest'
import { DisbursementsResponse } from './funds-transfers/responses/DisbursementsResponse'
import { QueryResponse } from './QueryResponse'
import { FundsTransfer } from './funds-transfers/FundsTransfer'
import { FetchResourceByIDRequest } from './FetchResourceByIDRequest'
import { TransferCashRequest } from './account-cash-transfers/requests/TransferCashRequest'
import { TransferCashResponse } from './account-cash-transfers/responses/TransferCashResponse'
import { WebhookConfig } from './webhooks/WebhookConfig'
import { UpdateWebhookRequest } from './webhooks/requests/UpdateWebHookRequest'
import { UpdateResponse } from './UpdateResponse'
import { AccountCashTransfer } from './account-cash-transfers/AccountCashTransfer'
import { UpdateContactRequest } from './contacts/requests/UpdateContactRequest'

export class PrimeTrustAPI extends BaseAPI {

  constructor(options: APIOptions) {
    super(options)
  }

  async getAgreementPreviews(getAgreementPreviewsRequest: GetAgreementPreviewsRequest): Promise<APIResponse<AgreementPreviewsResponse>> {
    const { include } = getAgreementPreviewsRequest
    delete getAgreementPreviewsRequest.include

    getAgreementPreviewsRequest.data.type = AgreementPreviewsType

    let reqUri = '/v2/agreement-previews'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      getAgreementPreviewsRequest,
    )

    return await this.executeRequest<AgreementPreviewsResponse>(req)
  }

  async openAccount(openAccountRequest: OpenAccountRequest): Promise<APIResponse<AccountResponse>> {
    const { include } = openAccountRequest

    delete openAccountRequest.include

    openAccountRequest.data.type = AccountsType

    let reqUri = '/v2/accounts'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      openAccountRequest,
    )

    return await this.executeRequest<AccountResponse>(req)
  }

  async getAccount(getAccountRequest: GetAccountRequest): Promise<APIResponse<AccountResponse>> {
    const { include } = getAccountRequest
    delete getAccountRequest.include
    const accountID = getAccountRequest['account-id']

    let reqUri = `/v2/accounts/${accountID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<AccountResponse>(req)
  }

  async updateContact(updateContactRequest: UpdateContactRequest): Promise<APIResponse<ContactResponse>> {
    const { id, include } = updateContactRequest
    delete updateContactRequest.id
    delete updateContactRequest.include

    updateContactRequest.data.type = ContactsType

    let reqUri = `/v2/contacts/${id}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().patch(
      reqUri,
      updateContactRequest,
    )

    return await this.executeRequest<ContactResponse>(req)
  }

  async getContact(getContactRequest: GetContactRequest): Promise<APIResponse<ContactResponse>> {
    const { include } = getContactRequest
    delete getContactRequest.include
    const contactID = getContactRequest['contact-id']

    let reqUri = `/v2/contacts/${contactID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<ContactResponse>(req)
  }

  async uploadKYCDocument(
    buff: Buffer,
    uploadDocumentRequest: UploadDocumentRequest
  ): Promise<APIResponse<UploadDocumentResponse>> {

    const form = new FormData()

    Object.entries(uploadDocumentRequest).forEach(([k, v]) => {
      form.append(k, v);
    })

    form.append('file', buff, 'foo.png')

    const headers = {
      'Content-Type': 'multipart/form-data; boundary=' + form.getBoundary(),
      'Content-Length': form.getLengthSync(),
    }

    const req = this.getAxiosInstance().post(
      `/v2/uploaded-documents`,
      form,
      { headers },
    )

    return await this.executeRequest<UploadDocumentResponse>(req)
  }

  async submitKycDocumentCheck(kycDocumentCheckRequest: SubmitKYCDocumentCheckRequest): Promise<APIResponse<KYCDocumentCheckResponse>> {
    const { include } = kycDocumentCheckRequest
    delete kycDocumentCheckRequest.include

    kycDocumentCheckRequest.data.type = KYCDocumentChecksType

    let reqUri = '/v2/kyc-document-checks'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      kycDocumentCheckRequest,
    )

    return await this.executeRequest<KYCDocumentCheckResponse>(req)
  }

  async getKycDocumentCheck(getKYCDocumentCheckRequest: GetKYCDocumentCheckRequest): Promise<APIResponse<GetKYCDocumentCheckResponse>> {
    const { include, kycDocumentCheckID } = getKYCDocumentCheckRequest
    delete getKYCDocumentCheckRequest.include

    let reqUri = `/v2/kyc-document-checks/${kycDocumentCheckID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<GetKYCDocumentCheckResponse>(req)
  }

  async sandboxFailKycDocumentCheck(failKYCDocumentCheckRequest: FailKYCDocumentCheckRequest): Promise<APIResponse<KYCDocumentCheckResponse>> {
    const { include, kycDocumentCheckID, data } = failKYCDocumentCheckRequest

    failKYCDocumentCheckRequest.data.type = KYCDocumentChecksType

    let reqUri = `/v2/kyc-document-checks/${kycDocumentCheckID}/sandbox/fail`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri, {
        data
      },
    )

    return await this.executeRequest<KYCDocumentCheckResponse>(req)
  }

  async sandboxVerifyKycDocumentCheck(verifyKYCDocumentCheckRequest: VerifyKYCDocumentCheckRequest): Promise<APIResponse<KYCDocumentCheckResponse>> {
    const { include, kycDocumentCheckID } = verifyKYCDocumentCheckRequest

    let reqUri = `/v2/kyc-document-checks/${kycDocumentCheckID}/sandbox/verify`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<KYCDocumentCheckResponse>(req)
  }

  async getAMLChecks(request: StandardQueryParams): Promise<APIResponse<GetAMLCheckResponse>> {
    const { filter, sort, include, page } = request
    delete request.include

    const req = this.getAxiosInstance().get(
      `/v2/aml-checks`, {
        params: filter,
      },
    )

    return await this.executeRequest<GetAMLCheckResponse>(req)
  }

  async simulateLongRunningRequest(
    idempotentID: string,
    request: DepositFundsUsingFundsTransferMethodRequest,
  ): Promise<APIResponse<ContributionsResponse>> {
    const { include } = request
    delete request.include

    request.data.type = ContributionsType

    let reqUri = '/v2/contributions/sandbox/timeout'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const headers = {
      'X-Idempotent-ID-V2': idempotentID,
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      request,
      { headers },
    )

    return await this.executeRequest<ContributionsResponse>(req)
  }

  async getAMLCheck(getAMLCheckRequest: GetAMLCheckRequest): Promise<APIResponse<GetAMLCheckResponse>> {
    const { include, amlCheckID } = getAMLCheckRequest
    delete getAMLCheckRequest.include

    let reqUri = `/v2/aml-checks/${amlCheckID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<GetAMLCheckResponse>(req)
  }

  async sandboxApproveAMLCheck(approveAMLCheckRequest: ApproveAMLCheckRequest): Promise<APIResponse<AMLCheckResponse>> {
    const { include, amlCheckID } = approveAMLCheckRequest

    let reqUri = `/v2/aml-checks/${amlCheckID}/sandbox/approve`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<AMLCheckResponse>(req)
  }

  async sandboxDenyAMLCheck(denyAMLCheckRequest: DenyAMLCheckRequest): Promise<APIResponse<AMLCheckResponse>> {
    const { include, amlCheckID } = denyAMLCheckRequest

    let reqUri = `/v2/aml-checks/${amlCheckID}/sandbox/deny`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<AMLCheckResponse>(req)
  }

  async submitCIPCheckForReview(submitCIPCheckForReviewRequest: SubmitCIPCheckForReviewRequest): Promise<APIResponse<CIPCheckResponse>> {
    const { include } = submitCIPCheckForReviewRequest
    delete submitCIPCheckForReviewRequest.include

    let reqUri = '/v2/cip-checks'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<CIPCheckResponse>(req)
  }

  async getCIPChecks(request: StandardQueryParams): Promise<APIResponse<GetCIPCheckResponse>> {
    const { filter, sort, include, page } = request
    delete request.include

    let reqUri = '/v2/cip-checks'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri, {
        params: filter,
        // params: {
        //   'account.id': accountID,
        // },
      },
    )

    return await this.executeRequest<GetCIPCheckResponse>(req)
  }

  async getCIPCheck(getCIPCheckRequest: GetCIPCheckRequest): Promise<APIResponse<CIPCheckResponse>> {
    const { include, cipCheckID } = getCIPCheckRequest
    delete getCIPCheckRequest.include

    let reqUri = `/v2/cip-checks/${cipCheckID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<CIPCheckResponse>(req)
  }

  async sandboxDenyCIPCheck(denyCIPCheckRequest: DenyCIPCheckRequest): Promise<APIResponse<CIPCheckResponse>> {
    const { include, cipCheckID } = denyCIPCheckRequest

    let reqUri = `/v2/cip-checks/${cipCheckID}/sandbox/deny`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<CIPCheckResponse>(req)
  }

  async sandboxApproveCIPCheck(approveCIPCheckRequest: ApproveCIPCheckRequest): Promise<APIResponse<CIPCheckResponse>> {
    const { include, cipCheckID } = approveCIPCheckRequest

    let reqUri = `/v2/cip-checks/${cipCheckID}/sandbox/approve`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<CIPCheckResponse>(req)
  }

  async sandboxClearFundsTransfer(request: ClearFundsTransferRequest): Promise<APIResponse<FundsTransferResponse>> {
    const { include, fundsTransferID } = request
    delete request.include
    delete request.fundsTransferID

    let reqUri = `/v2/funds-transfers/${fundsTransferID}/sandbox/clear`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<FundsTransferResponse>(req)
  }

  async sandboxSettleFundsTransfer(request: SettleFundsTransferRequest): Promise<APIResponse<FundsTransferResponse>> {
    const { include, fundsTransferID, data } = request
    delete request.include
    delete request.fundsTransferID

    request.data.type = FundsTransfersType

    let reqUri = `/v2/funds-transfers/${fundsTransferID}/sandbox/settle`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    // tslint:disable: no-console
    // console.log('reqUri:', reqUri)
    // console.log('data:', data)

    const req = this.getAxiosInstance().post(
      reqUri, {
        data
      },
    )

    return await this.executeRequest<FundsTransferResponse>(req)
  }

  async sandboxReverseFundsTransfer(request: ReverseFundsTransferRequest): Promise<APIResponse<FundsTransferResponse>> {
    const { include, fundsTransferID, data } = request
    delete request.include
    delete request.fundsTransferID

    request.data.type = FundsTransfersType

    let reqUri = `/v2/funds-transfers/${fundsTransferID}/sandbox/reverse`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri, {
        data
      },
    )

    return await this.executeRequest<FundsTransferResponse>(req)
  }

  async getAccountAssetTotals(assetTotalsRequest: AssetTotalsRequest): Promise<APIResponse<AssetTotalsResponse>> {
    const req = this.getAxiosInstance().get(
      `/v2/account-asset-totals`, {
        params: assetTotalsRequest
      },
    )

    return await this.executeRequest<AssetTotalsResponse>(req)
  }

  async getAccountAssetTotalsByAccountID(accountID: string): Promise<APIResponse<AssetTotalsResponse>> {
    const req = this.getAxiosInstance().get(
      `/v2/account-asset-totals`,  {
        params: {
          'account.id': accountID,
        },
      },
    )

    return await this.executeRequest<AssetTotalsResponse>(req)
  }

  async getAccountCashTotalsEx(cashTotalsRequest: CashTotalsRequest): Promise<APIResponse<CashTotalsResponse>> {
    const req = this.getAxiosInstance().get(
      `/v2/account-cash-totals`, {
        params: cashTotalsRequest
      },
    )

    return await this.executeRequest<CashTotalsResponse>(req)
  }

  async getAccountCashTotalsByAccountID(accountID: string): Promise<APIResponse<CashTotalsResponse>> {
    const req = this.getAxiosInstance().get(
      `/v2/account-cash-totals`, {
        params: {
          'account.id': accountID,
        },
      },
    )

    return await this.executeRequest<CashTotalsResponse>(req)
  }

  async getContingentHoldsByResourceID(
    params: object,
  ): Promise<APIResponse<QueryResponse<ContingentHold[]>>> {
    const req = this.getAxiosInstance().get(
      `/v2/contingent-holds`, {
        params,
      },
    )

    return await this.executeRequest<QueryResponse<ContingentHold[]>>(req)
  }

  async getContingentHoldByID(request: GetContingentHoldRequest): Promise<APIResponse<QueryResponse<ContingentHold>>> {
    const { include, id } = request
    delete request.include

    let reqUri = `/v2/contingent-holds/${id}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<QueryResponse<ContingentHold>>(req)
  }

  async sandboxClearContingentHold(request: ClearContingentHoldRequest): Promise<APIResponse<QueryResponse<ContingentHold>>> {
    const { include, contingentHoldID, data } = request
    delete request.include
    delete request.contingentHoldID

    request.data.type = ContingentHoldsType

    let reqUri = `/v2/contingent-holds/${contingentHoldID}/sandbox/clear`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri, {
        data
      },
    )

    return await this.executeRequest<QueryResponse<ContingentHold>>(req)
  }

  async createFundsTransferMethod(
    request: CreateProcessorTokenFundsTransferMethodRequest,
  ): Promise<APIResponse<FundsTransferMethodResponse>> {
    const { include } = request
    delete request.include

    request.data.type = FundsTransferMethodsType

    let reqUri = '/v2/funds-transfer-methods'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      request,
    )

    return await this.executeRequest<FundsTransferMethodResponse>(req)
  }

  async depositFundsUsingFundsTransferMethod(
    idempotentID: string,
    request: DepositFundsUsingFundsTransferMethodRequest,
  ): Promise<APIResponse<ContributionsResponse>> {
    const { include } = request
    delete request.include

    request.data.type = ContributionsType

    let reqUri = '/v2/contributions'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const headers = {
      'X-Idempotent-ID-V2': idempotentID,
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      request,
      { headers },
    )

    return await this.executeRequest<ContributionsResponse>(req)
  }

  async withdrawFundsUsingFundsTransferMethod(
    idempotentID: string,
    request: WithdrawFundsUsingFundsTransferMethodRequest,
  ): Promise<APIResponse<DisbursementsResponse>> {
    const { include } = request
    delete request.include

    request.data.type = DisbursementsType

    let reqUri = '/v2/disbursements'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const headers = {
      'X-Idempotent-ID-V2': idempotentID,
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      request,
      { headers },
    )

    return await this.executeRequest<DisbursementsResponse>(req)
  }

  async cancelFundsTransfer(request: FetchResourceByIDRequest): Promise<APIResponse<FundsTransferResponse>> {
    const { include, id } = request
    delete request.include
    delete request.id

    let reqUri = `/v2/funds-transfers/${id}/cancel`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().post(
      reqUri,
    )

    return await this.executeRequest<FundsTransferResponse>(req)
  }

  async getFundsTransferByID(
    request: FetchResourceByIDRequest,
  ): Promise<APIResponse<QueryResponse<FundsTransfer>>> {
    const { include, id } = request
    delete request.include

    let reqUri = `/v2/funds-transfers/${id}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<QueryResponse<FundsTransfer>>(req)
  }

  async getFundsTransfersForAccount(
    accountID: string,
  ): Promise<APIResponse<QueryResponse<FundsTransfer[]>>> {
    const req = this.getAxiosInstance().get(
      `/v2/funds-transfers`, {
        params: {
          'account.id': accountID,
        },
      },
    )

    return await this.executeRequest<QueryResponse<FundsTransfer[]>>(req)
  }

  async getFundsTransfers(
    query: Query,
  ): Promise<APIResponse<QueryResponse<FundsTransfer[]>>> {
    const req = this.getAxiosInstance().get(
      `/v2/funds-transfers`, {
        params: {
          // 'filter[id eq]': 'cdc84352-36a0-4e64-b1f8-21ddbae73b23',
          'funds-transfers.id': 'cdc84352-36a0-4e64-b1f8-21ddbae73b23',
        },
      },
    )

    // GET v2/funds-transfers?filter[id eq]={{funds-transfer-id}}&include=contingent-holds

    return await this.executeRequest<QueryResponse<FundsTransfer[]>>(req)
  }

  async transferCash(
    idempotentID: string,
    request: TransferCashRequest,
  ): Promise<APIResponse<TransferCashResponse>> {
    const { include } = request
    delete request.include

    request.data.type = ContributionsType

    let reqUri = '/v2/account-cash-transfers'
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const headers = {
      'X-Idempotent-ID-V2': idempotentID,
    }

    const req = this.getAxiosInstance().post(
      reqUri,
      request,
      { headers },
    )

    return await this.executeRequest<TransferCashResponse>(req)
  }

  async getCashTransferByID(
    request: FetchResourceByIDRequest,
  ): Promise<APIResponse<QueryResponse<AccountCashTransfer>>> {
    const { include, id } = request
    delete request.include

    let reqUri = `/v2/account-cash-transfers/${id}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<QueryResponse<AccountCashTransfer>>(req)
  }

  async getWebhookConfigByID(
    request: FetchResourceByIDRequest,
  ): Promise<APIResponse<QueryResponse<WebhookConfig>>> {
    const { include, id } = request
    delete request.include

    let reqUri = `/v2/webhook-configs/${id}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().get(
      reqUri,
    )

    return await this.executeRequest<QueryResponse<WebhookConfig>>(req)
  }

  async getWebHooksForAccount(
    accountID: string,
  ): Promise<APIResponse<QueryResponse<WebhookConfig[]>>> {
    const req = this.getAxiosInstance().get(
      `/v2/webhook-configs`, {
        params: {
          'account.id': accountID,
        },
      },
    )

    return await this.executeRequest<QueryResponse<WebhookConfig[]>>(req)
  }

  async updateWebhookConfig(
    request: UpdateWebhookRequest,
  ): Promise<APIResponse<UpdateResponse<WebhookConfig>>> {
    const { include, webhookID, data } = request
    delete request.include
    delete request.webhookID

    request.data.type = WebhookConfigsType

    let reqUri = `/v2/webhook-configs/${webhookID}`
    if (include) {
      reqUri = `${reqUri}?include=${include}`
    }

    const req = this.getAxiosInstance().patch(
      reqUri, {
        data
      },
    )

    return await this.executeRequest<UpdateResponse<WebhookConfig>>(req)
  }
}