@nombaoss/nomba-node 0.0.0-stage → 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1365 @@
+/**
+ * Request and response types, from the Nomba OpenAPI spec (NombaOSS/openapi v0.1.0).
+ * Response types allow extra fields: Nomba adds fields without notice.
+ */
+/** Allows fields not (yet) described in the spec. */
+interface Extra {
+    [key: string]: unknown;
+}
+/** Cursor-paginated list. An empty or absent `cursor` means this is the last page. */
+interface CursorPage<T> extends Extra {
+    results?: T[];
+    cursor?: string;
+}
+interface PageOptions {
+    /** Page size, 1–50. */
+    limit?: number;
+    /** Cursor from the previous page. */
+    cursor?: string;
+}
+interface DateRange {
+    /** Start date, e.g. `2025-01-01T00:00:00`. */
+    dateFrom?: string;
+    dateTo?: string;
+}
+interface SubAccountOption {
+    /** Act on this sub account instead of the parent account. */
+    subAccountId?: string;
+}
+type TransactionStatusValue = "SUCCESS" | "PENDING_BILLING" | "PROCESSING" | "REFUND" | "CANCELLED" | "PAYMENT_FAILED" | "REVERSED_BY_VENDOR";
+type TransactionSource = "api" | "pos" | "web" | "android_app" | "ios_app";
+type TransactionType = "withdrawal" | "purchase" | "transfer" | "p2p" | "online_checkout" | "qrt_credit" | "qrt_debit";
+/** String unions widened with `string` so new values don't break your build. */
+type Open<T extends string> = T | (string & {});
+interface RevokeTokenResult extends Extra {
+}
+interface Account extends Extra {
+    createdAt: string;
+    accountId: string;
+    accountHolderId: string;
+    accountRef: string;
+    bvn: string;
+    status: Open<"ACTIVE" | "INACTIVE" | "SUSPENDED" | "PND" | "BLACKLISTED">;
+    type: Open<"virtual" | "outlet">;
+    accountName: string;
+    currency: Open<"NGN">;
+    banks?: Array<{
+        bankAccountNumber: string;
+        bankName: string;
+        bankAccountName: string;
+    }>;
+}
+interface Balance extends Extra {
+    amount: string;
+    currency: Open<"NGN">;
+    timeCreated: string;
+}
+interface GetBalanceParams extends SubAccountOption {
+}
+interface GetSubAccountParams {
+    accountId?: string;
+    accountRef?: string;
+}
+interface Terminal extends Extra {
+    terminalId: string;
+    serialNumber: string;
+    accountId: string;
+    parentAccountId: string;
+    merchantName: string;
+    terminalLabel: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListTerminalsParams extends SubAccountOption, PageOptions {
+    terminalId?: string;
+    serialNumber?: string;
+    terminalLabel?: string;
+    merchantName?: string;
+}
+interface CreateVirtualAccountParams {
+    /** Your unique reference for the account. */
+    accountRef: string;
+    accountName: string;
+    bvn?: string;
+    nin?: string;
+    expiryDate?: string;
+    expectedAmount?: number;
+    restrictInflowToAccountName?: boolean;
+    callbackUrl?: string;
+}
+interface VirtualAccount extends Extra {
+    createdAt: string;
+    accountHolderId: string;
+    accountRef: string;
+    bvn: string;
+    identifierType?: Open<"BVN" | "NIN" | "BVN_AND_NIN">;
+    accountName: string;
+    bankName?: string;
+    bankAccountNumber?: string;
+    bankAccountName?: string;
+    currency: Open<"NGN">;
+    callbackUrl?: string;
+    expired?: boolean;
+    restrictInflowToAccountName?: boolean;
+}
+interface UpdateVirtualAccountParams {
+    newAccountRef?: string;
+    accountName?: string;
+    expectedAmount?: string;
+}
+interface UpdateVirtualAccountResult extends Extra {
+    updated: boolean;
+}
+interface ExpireVirtualAccountResult extends Extra {
+    expired: boolean;
+}
+interface VirtualAccountFilters {
+    accountName?: string;
+    accountRef?: string;
+    bvn?: string;
+    bankAccountNumber?: string;
+    dateCreatedFrom?: string;
+    dateCreatedTo?: string;
+    expired?: boolean;
+    resourceAcquired?: boolean;
+}
+type CheckoutCurrency = Open<"NGN" | "CDF" | "USD">;
+interface SplitRequest {
+    splitType?: Open<"PERCENTAGE" | "AMOUNT">;
+    splitList?: Array<{
+        accountId?: string;
+        value?: number;
+    }>;
+}
+interface CheckoutOrderInput {
+    orderReference?: string;
+    customerId?: string;
+    callbackUrl: string;
+    customerEmail: string;
+    amount: number;
+    currency: CheckoutCurrency;
+    accountId?: string;
+    allowedPaymentMethods?: string[];
+    splitRequest?: SplitRequest;
+    orderMetaData?: Record<string, unknown>;
+}
+interface CreateOrderParams {
+    order: CheckoutOrderInput;
+    /** Save the customer's card for later charges with `chargeSavedCard`. */
+    tokenizeCard?: boolean;
+}
+interface CreateOrderResult extends Extra {
+    checkoutLink: string;
+    orderReference: string;
+}
+interface CheckoutOrder extends Extra {
+    orderId?: string;
+    orderReference?: string;
+    customerId?: string;
+    accountId?: string;
+    callbackUrl?: string;
+    customerEmail?: string;
+    amount?: number;
+    currency?: string;
+    businessName?: string;
+    businessEmail?: string;
+    businessLogo?: string;
+}
+interface GetOrderResult extends Extra {
+    order?: CheckoutOrder;
+    hasSavedCards?: boolean;
+    base64EncodedRsaPublicKey?: string;
+}
+interface OrderReferenceParams {
+    orderReference: string;
+}
+interface SuccessMessage extends Extra {
+    success: boolean;
+    message: string;
+}
+interface StatusMessage extends Extra {
+    status?: boolean;
+    message?: string;
+}
+interface GetCheckoutTransactionParams {
+    idType: Open<"ORDER_ID" | "ORDER_REFERENCE">;
+    id: string;
+}
+interface CheckoutTransaction extends Extra {
+    success?: boolean;
+    message?: string;
+    order?: CheckoutOrder;
+    transactionDetails?: Extra & {
+        transactionDate?: string;
+        paymentReference?: string;
+        paymentVendorReference?: string;
+        tokenizedCardPayment?: boolean;
+        statusCode?: string;
+        status?: Open<"PENDING" | "PAYMENT SUCCESSFUL" | "FAILED PAYMENT">;
+    };
+    transferDetails?: Extra & {
+        sessionId?: string;
+        beneficiaryAccountName?: string;
+        beneficiaryAccountNumber?: string;
+        originatorAccountName?: string;
+        originatorAccountNumber?: string;
+        narration?: string;
+        destinationInstitutionCode?: string;
+        paymentReference?: string;
+    };
+    cardDetails?: Extra & {
+        cardPan?: string;
+        cardType?: string;
+        cardCurrency?: string;
+        cardBank?: string;
+    };
+}
+interface RefundParams {
+    transactionId: string;
+    amount?: number;
+    accountNumber?: string;
+    bankCode?: string;
+}
+interface ChargeSavedCardParams {
+    /**
+     * The order to charge. If `order.orderReference` is omitted the SDK generates one
+     * (UUID v4) and returns it as `orderReference`; reuse it to requery.
+     */
+    order: CheckoutOrderInput;
+    /** The card token from the `payment_success` webhook. */
+    tokenKey: string;
+}
+interface ChargeSavedCardResult extends Extra {
+    status?: boolean;
+    message?: string;
+    orderId?: string;
+    orderReference?: string;
+    /** The customer's bank wants an OTP: submit it with `checkout.submitCardOtp`. */
+    otpRequired?: boolean;
+    transactionId?: string;
+}
+interface SavedCard extends Extra {
+    tokenKey?: string;
+    customerEmail?: string;
+    cardType?: string;
+    cardPan?: string;
+    tokenExpiryDate?: string;
+}
+interface ListSavedCardsParams extends DateRange {
+    customerEmail?: string;
+    page?: number;
+    limit?: number;
+}
+interface SavedCardList extends Extra {
+    hasNextPage?: boolean;
+    nextPage?: number;
+    tokenizedCardDataList?: SavedCard[];
+}
+interface UpdateSavedCardEmailParams {
+    tokenKey: string;
+    currentEmailAddress: string;
+    newEmailAddress: string;
+}
+interface UpdateSavedCardEmailResult extends StatusMessage {
+    tokenizedCardData?: SavedCard;
+}
+interface DeleteSavedCardParams {
+    tokenKey: string;
+}
+interface TransferAccount extends Extra {
+    accountNumber: string;
+    accountName: string;
+    bankName: string;
+}
+interface DeviceInformation {
+    httpBrowserLanguage?: string;
+    httpBrowserJavaEnabled?: boolean;
+    httpBrowserJavaScriptEnabled?: boolean;
+    httpBrowserColorDepth?: string;
+    httpBrowserScreenHeight?: string;
+    httpBrowserScreenWidth?: string;
+    httpBrowserTimeDifference?: string;
+    userAgentBrowserValue?: string;
+    deviceChannel?: string;
+}
+interface SubmitCardDetailsParams {
+    /** RSA-encrypted card details. */
+    cardDetails?: string;
+    key?: string;
+    orderReference?: string;
+    saveCard?: boolean;
+    deviceInformation?: DeviceInformation;
+}
+interface SubmitCardDetailsResult extends Extra {
+    status?: boolean;
+    message?: string;
+    responseCode?: string;
+    transactionId?: string;
+    secureAuthenticationData?: Extra & {
+        jwt?: string;
+        md?: string;
+        acsUrl?: string;
+        termUrl?: string;
+    };
+}
+interface SubmitCardOtpParams {
+    otp: string;
+    orderReference: string;
+    transactionId: string;
+}
+interface SubmitCardOtpResult extends Extra {
+    status: boolean;
+    message: string;
+}
+interface ConfirmTransactionReceiptResult extends Extra {
+    status: boolean;
+    message: string;
+    order?: CheckoutOrder;
+}
+interface CancelTransactionParams {
+    transactionId: string;
+    forceCancel: boolean;
+}
+interface RequestSaveCardOtpParams {
+    orderReference: string;
+    phoneNumber: string;
+}
+interface SubmitUserOtpParams {
+    orderReference: string;
+    phoneNumber: string;
+    otp: string;
+}
+interface GetSavedCardsParams {
+    otp: string;
+}
+interface UserSavedCards extends Extra {
+    tokenizedCardData?: unknown;
+}
+interface Bank extends Extra {
+    code?: string;
+    name?: string;
+    nipCode?: string;
+    logo?: string;
+}
+interface LookupAccountParams {
+    accountNumber: string;
+    bankCode: string;
+}
+interface AccountLookupResult extends Extra {
+    accountNumber?: string;
+    accountName?: string;
+}
+interface MerchantTxRefOption {
+    /**
+     * Your unique reference for this transaction. If omitted the SDK generates one
+     * (UUID v4) and returns it. Reuse the same value when retrying so Nomba can
+     * deduplicate.
+     */
+    merchantTxRef?: string;
+}
+interface BankTransferParams extends MerchantTxRefOption {
+    amount: number;
+    accountNumber: string;
+    accountName: string;
+    bankCode: string;
+    senderName?: string;
+    narration?: string;
+}
+interface BankTransferResult extends Extra {
+    id: string;
+    amount: string;
+    status: Open<TransactionStatusValue>;
+    type: Open<TransactionType>;
+    fee: number;
+    timeCreated: string;
+    source?: string;
+    sourceUserId?: string;
+    customerBillerId?: string;
+    productId?: string;
+    meta: Extra & {
+        merchantTxRef?: string;
+        sessionId?: string;
+        narration?: string;
+        recipientName?: string;
+        accountNumber?: string;
+        bankName?: string;
+        bankCode?: string;
+    };
+    /** The reference sent (generated by the SDK if you did not pass one). */
+    merchantTxRef: string;
+}
+interface WalletTransferParams extends MerchantTxRefOption {
+    amount: number;
+    /** The Nomba account ID receiving the funds. */
+    receiverAccountId: string;
+    narration?: string;
+}
+interface WalletTransferResult extends Extra {
+    id: string;
+    amount: number;
+    status: Open<TransactionStatusValue>;
+    type: Open<TransactionType>;
+    fee: number;
+    timeCreated: string;
+    meta: Extra & {
+        merchantTxRef?: string;
+        api_client_id?: string;
+        api_account_id?: string;
+        rrn?: string;
+    };
+    /** The reference sent (generated by the SDK if you did not pass one). */
+    merchantTxRef: string;
+}
+interface Transaction extends Extra {
+    id: string;
+    status: Open<TransactionStatusValue>;
+    amount: number;
+    fixedCharge?: number;
+    source: Open<TransactionSource>;
+    type: Open<TransactionType>;
+    gatewayMessage: string;
+    customerBillerId?: string;
+    timeCreated: string;
+    posTid?: string;
+    terminalId?: string;
+    providerTerminalId?: string;
+    rrn?: string;
+    posSerialNumber?: string;
+    posTerminalLabel?: string;
+    stan?: string;
+    paymentVendorReference?: string;
+    userId?: string;
+    posRrn?: string;
+    merchantTxRef?: string;
+}
+interface ListTransactionsParams extends SubAccountOption, PageOptions, DateRange {
+}
+interface TransactionFilters {
+    transactionRef?: string;
+    status?: Open<"NEW" | "PENDING_PAYMENT" | "PAYMENT_SUCCESSFUL" | "PAYMENT_FAILED" | "PENDING_BILLING" | "SUCCESS" | "REFUND">;
+    source?: Open<TransactionSource>;
+    type?: Open<TransactionType>;
+    terminalId?: string;
+    rrn?: string;
+    merchantTxRef?: string;
+    orderReference?: string;
+    orderId?: string;
+}
+interface GetTransactionParams extends SubAccountOption {
+    transactionRef?: string;
+    merchantTxRef?: string;
+    orderReference?: string;
+    orderId?: string;
+}
+interface ListBankTransactionsParams extends PageOptions, DateRange {
+}
+interface BankTransaction extends Extra {
+    amount: number;
+    currency: Open<"NGN">;
+    meta: Extra & {
+        billerId?: string;
+        terminalActionId?: string;
+        productId?: string;
+        fee?: number;
+        type?: string;
+        transactionId?: string;
+        rrn?: string;
+        parentAccountId?: string;
+        terminalLabel?: string;
+        accountId?: string;
+        merchantTxRef?: string;
+        transactionAmount?: number;
+        mCollectionsId?: string;
+    };
+    status: Open<TransactionStatusValue>;
+    timeUpdated: string;
+    walletBalance: number;
+    transactionType: Open<"CREDIT" | "DEBIT">;
+}
+interface AssignTerminalParams {
+    serialNumber: string;
+    terminalLabel?: string;
+}
+interface TerminalPaymentRequestParams {
+    merchantTxRef: string;
+    amount: number;
+    currency: Open<"NGN" | "USD" | "CDF">;
+}
+interface TerminalPaymentRequestResult extends Extra {
+    paymentId: string;
+    status: Open<"pending" | "completed" | "failed">;
+    amount: number;
+    currency: string;
+    createdAt: string;
+}
+type MandateFrequency = Open<"VARIABLE" | "WEEKLY" | "EVERY_TWO_WEEKS" | "MONTHLY" | "EVERY_TWO_MONTHS" | "EVERY_THREE_MONTHS" | "EVERY_FOUR_MONTHS" | "EVERY_FIVE_MONTHS" | "EVERY_SIX_MONTHS" | "EVERY_SEVEN_MONTHS" | "EVERY_EIGHT_MONTHS" | "EVERY_NINE_MONTHS" | "EVERY_TEN_MONTHS" | "EVERY_ELEVEN_MONTHS" | "EVERY_TWELVE_MONTHS">;
+interface CreateMandateParams {
+    customerAccountNumber: string;
+    bankCode: string;
+    customerName: string;
+    customerAddress?: string;
+    customerAccountName: string;
+    amount: number;
+    frequency: MandateFrequency;
+    narration?: string;
+    customerPhoneNumber?: string;
+    merchantReference: string;
+    startDate: string;
+    endDate: string;
+    customerEmail: string;
+    startImmediately?: boolean;
+}
+interface CreateMandateResult extends Extra {
+    mandateId: string;
+    merchantReference: string;
+    phoneNumber: string;
+    description: string;
+}
+interface DebitMandateParams {
+    mandateId: string;
+    amount: string;
+}
+interface DebitMandateResult extends Extra {
+    mandateId?: string;
+    status?: string;
+    amount?: string;
+    message?: string;
+}
+interface MandateStatus extends Extra {
+    customerAccountName: string;
+    mandateId: string;
+    customerAccountNumber: string;
+    mandateStatus: string;
+    rejectionComment?: string;
+    mandateAdviceStatus?: string;
+}
+interface ListMandatesParams {
+    page?: number;
+    pageSize?: number;
+    from?: string;
+    to?: string;
+    status?: string;
+}
+interface Mandate extends Extra {
+    status?: string;
+    customerAccountNumber?: string;
+    customerAccountName?: string;
+    bankCode?: string;
+    amount?: number;
+    customerName?: string;
+    customerAddress?: string;
+    customerEmail?: string;
+    customerPhoneNumber?: string;
+    merchantReference?: string;
+    frequency?: string;
+    startDate?: string;
+    endDate?: string;
+    mandateAdviceStatus?: string;
+    mandateId?: string;
+}
+interface MandateList extends Extra {
+    /** The spec types this as an object; in practice it may be a list. */
+    items?: Mandate | Mandate[];
+    page?: number;
+    pageSize?: number;
+    totalItems?: number;
+    totalPages?: number;
+    hasMore?: boolean;
+}
+interface UpdateMandateStatusParams {
+    mandateId: string;
+    status: Open<"SUSPEND" | "ACTIVE" | "DELETE">;
+}
+interface UpdateMandateStatusResult extends Extra {
+    mandateId?: string;
+    mandateStatus?: string;
+}
+type Network = Open<"GLO" | "MTN" | "9MOBILE" | "AIRTEL">;
+interface BuyAirtimeParams extends MerchantTxRefOption {
+    amount: number;
+    phoneNumber: string;
+    network: Network;
+    senderName?: string;
+}
+interface BuyDataParams extends MerchantTxRefOption {
+    /** From `bills.listDataPlans`. */
+    productId: string;
+    amount?: number;
+    phoneNumber: string;
+    network: Network;
+    senderName?: string;
+}
+interface BuyElectricityParams extends MerchantTxRefOption {
+    disco?: string;
+    payerName?: string;
+    amount?: number;
+    customerId?: string;
+    meterType?: string;
+}
+interface PayCableTvParams extends MerchantTxRefOption {
+    cableTvType?: string;
+    payerName?: string;
+    amount?: number;
+    customerId?: string;
+}
+interface FundBettingParams extends MerchantTxRefOption {
+    bettingProvider?: string;
+    phoneNumber?: string;
+    payerName?: string;
+    amount?: number;
+    customerId?: string;
+}
+interface BillPurchaseResult extends Extra {
+    id: string;
+    status: Open<TransactionStatusValue>;
+    type: string;
+    amount: number;
+    source?: string;
+    sourceUserId?: string;
+    customerBillerId?: string;
+    productId?: string;
+    meta?: Extra;
+    userId?: string;
+    timeCreated: string;
+    /** The reference sent (generated by the SDK if you did not pass one). */
+    merchantTxRef: string;
+}
+interface DataPlan extends Extra {
+    amount?: number;
+    productId?: string;
+}
+interface LookupElectricityCustomerParams {
+    disco: string;
+    customerId: string;
+}
+interface ElectricityCustomer extends Extra {
+    name: string;
+    address: string;
+}
+type CableTvType = Open<"dstv" | "gotv" | "startimes" | "showmax">;
+interface CableTvPlan extends Extra {
+    subScriptionType: string;
+    amount: number;
+}
+interface LookupCableTvCustomerParams {
+    customerId: string;
+    cableTvType: CableTvType;
+}
+interface BettingProvider extends Extra {
+    name: string;
+    id: string;
+}
+interface LookupBettingCustomerParams {
+    providerId: string;
+    customerId: string;
+}
+interface GlobalPayoutAccount extends Extra {
+    accountId?: string;
+    name?: string;
+    currency?: string;
+    balance?: number;
+    availableBalance?: number;
+    status?: Open<"ACTIVE" | "UNAVAILABLE">;
+    operationRegion?: string;
+}
+interface ListBankProvidersParams {
+    isMobileMoney?: boolean;
+    countryIsoCode?: string;
+}
+interface Provider extends Extra {
+    code?: string;
+    displayName?: string;
+}
+interface GetExchangeRatesParams {
+    from: string;
+    to: string;
+    region?: string;
+}
+interface ExchangeRates extends Extra {
+    rates?: Array<Extra & {
+        exchangeRateId?: string;
+        currencyPairName?: string;
+        bidRate?: string;
+        askRate?: string;
+        midRate?: string;
+        createdAt?: string;
+    }>;
+}
+interface ListPaymentMethodsParams {
+    destinationCountryIsoCode?: string;
+    destinationCurrency?: string;
+    code?: string;
+    name?: string;
+}
+interface PaymentMethod extends Extra {
+    code?: string;
+    displayName?: string;
+    purposeOfPaymentRequired?: boolean;
+    purposeOfPayments?: Provider[];
+    requiredFields?: string[];
+    optionalFields?: string[];
+    accountTypes?: string[];
+    bankAccountTypes?: string[];
+    supportedCorridors?: Array<Extra & {
+        countryIsoCode?: string;
+        currency?: string;
+    }>;
+}
+interface GlobalPayoutTransaction extends Extra {
+    transactionId?: string;
+    status?: Open<"PROCESSING" | "COMPLETED" | "FAILED" | "PENDING">;
+    coreStatus?: string;
+    type?: string;
+    createdAt?: string;
+    idempotencyKey?: string;
+}
+interface AuthorizeExchangeParams {
+    amount: number;
+    sourceCurrency: string;
+    destinationCurrency: string;
+    senderName: string;
+    receiverName: string;
+    sourceCountryIsoCode: string;
+    destinationCountryIsoCode: string;
+    narration?: string;
+    lockedExchangeRateId?: string;
+    /** Reuse the same key when retrying so Nomba can deduplicate. */
+    idempotencyKey?: string;
+}
+interface AuthorizeExchangeResult extends Extra {
+    wtTransactionId?: string;
+    coreTransactionId?: string;
+    status?: string;
+    coreStatus?: string;
+    type?: string;
+    idempotencyKey?: string;
+    idempotentReplay?: boolean;
+}
+interface ConvertMoneyParams {
+    amount: number;
+    currency: string;
+    destinationCurrency: string;
+    transactionType: string;
+}
+interface ConvertMoneyResult extends Extra {
+    fromAmount?: number;
+    fromCurrency?: string;
+    fromFormatted?: string;
+    toAmount?: number;
+    toCurrency?: string;
+    toFormatted?: string;
+    spreadAmount?: number;
+    spreadCurrency?: string;
+    exchangeRateId?: string;
+    currencyPairName?: string;
+    feeAmount?: number;
+    feeCurrency?: string;
+}
+interface AuthorizeTransferParams {
+    amount: number;
+    sourceCurrency: string;
+    destinationCurrency: string;
+    receiverName: string;
+    sourceCountryIsoCode: string;
+    destinationCountryIsoCode: string;
+    paymentMethod: Open<"BANK" | "MobileMoney" | "INTERAC" | "FASTER_PAYMENTS" | "SEPA" | "ACH" | "WIRE">;
+    accountNumber?: string;
+    institutionCode?: string;
+    institutionName?: string;
+    accountType: Open<"INDIVIDUAL" | "CORPORATE">;
+    bankAccountType?: Open<"CHECKING" | "SAVINGS">;
+    purposeOfPayment?: string;
+    narration?: string;
+    lockedExchangeRateId?: string;
+    /** Reuse the same key when retrying so Nomba can deduplicate. */
+    idempotencyKey?: string;
+    bankAddress?: string;
+    bankCity?: string;
+    bankState?: string;
+    bankZipCode?: string;
+    beneficiary?: {
+        beneficiaryEmail?: string;
+        securityQuestion?: string;
+        securityQuestionAnswer?: string;
+        transitNumber?: string;
+        beneficiaryAddress?: string;
+        beneficiaryCity?: string;
+        beneficiaryState?: string;
+        beneficiaryPostCode?: string;
+    };
+}
+interface AuthorizeTransferResult extends AuthorizeExchangeResult {
+    prettyStatus?: string;
+    meta?: Extra;
+}
+interface InitiateInflowParams {
+    phoneNumber: string;
+    callbackUrl: string;
+    amount: number;
+    currency: string;
+    /** Provider code from `globalCollection.listDrcProviders`. */
+    topupVendor: string;
+    /** Reuse the same key when retrying so Nomba can deduplicate. */
+    idempotencyKey?: string;
+}
+interface InitiateInflowResult extends Extra {
+    transactionReference?: string;
+    status?: string;
+    message?: string;
+    idempotencyKey?: string;
+}
+interface CollectionTransaction extends Extra {
+    transactionId?: string;
+    coreUserId?: string;
+    account?: string;
+    status?: Open<"PENDING" | "APPROVED" | "SUCCESS" | "FAILED" | "PENDING_APPROVAL">;
+    amount?: number;
+    currency?: string;
+    vendor?: string;
+    gatewayMessage?: string;
+    gatewayCode?: string;
+}
+interface WebhookEvent extends Extra {
+    event_type: string;
+    requestId: string;
+    data: Extra & {
+        merchant: Extra & {
+            userId?: string;
+            walletId?: string;
+            walletBalance?: number;
+        };
+        transaction: Extra & {
+            transactionId?: string;
+            type?: string;
+            time?: string;
+            responseCode?: string | null;
+            transactionAmount?: number;
+            fee?: number;
+            sessionId?: string;
+            merchantTxRef?: string;
+            narration?: string;
+        };
+        terminal?: Extra;
+        customer?: Extra;
+        order?: Extra;
+        tokenizedCardData?: Extra;
+    };
+}
+
+/** Headers as a fetch `Headers` object or a plain object (e.g. Node's `req.headers`). */
+type WebhookHeaders = {
+    get(name: string): string | null;
+} | Record<string, string | string[] | undefined>;
+interface VerifyWebhookOptions {
+    /**
+     * Reject events whose `nomba-timestamp` is more than this many seconds away from
+     * now (replay protection). Off by default.
+     */
+    toleranceSeconds?: number;
+    /** Override the clock (for tests). */
+    now?: Date;
+}
+/** base64(HMAC-SHA256(signingKey, message)). */
+declare function computeWebhookSignature(event: WebhookEvent, timestamp: string, signingKey: string): string;
+/**
+ * Verify a Nomba webhook and return the parsed event. Throws
+ * {@link WebhookVerificationError} if the signature or payload is not valid.
+ *
+ * Pass the **raw** request body exactly as received. Re-serialising a parsed
+ * object can change it and break verification.
+ */
+declare function verifyWebhook(rawBody: string | Uint8Array | ArrayBuffer, headers: WebhookHeaders, signingKey: string, options?: VerifyWebhookOptions): WebhookEvent;
+
+/** An access token as kept by a {@link TokenStore}. */
+interface Token {
+    accessToken: string;
+    refreshToken: string;
+    /** RFC 3339 expiry time from Nomba's `expiresAt`. */
+    expiresAt: string;
+}
+/**
+ * Where the client keeps its access token. The default keeps it in memory.
+ * Implement this (e.g. over Redis) so several instances share one token:
+ * Nomba recommends a single authenticating instance.
+ */
+interface TokenStore {
+    get(): Token | null | Promise<Token | null>;
+    set(token: Token | null): void | Promise<void>;
+}
+/** Default token store: one token per client, held in memory. */
+declare class InMemoryTokenStore implements TokenStore {
+    #private;
+    get(): Token | null;
+    set(token: Token | null): void;
+    toJSON(): Record<string, string>;
+}
+interface TokenResponse {
+    access_token?: unknown;
+    refresh_token?: unknown;
+    expiresAt?: unknown;
+}
+interface TokenManagerDeps {
+    store: TokenStore;
+    issue(): Promise<TokenResponse>;
+    refresh(refreshToken: string): Promise<TokenResponse>;
+    now?: () => number;
+}
+/**
+ * Lazily obtains tokens, refreshes them before they expire and makes sure
+ * concurrent callers share a single in-flight token request.
+ */
+declare class TokenManager {
+    #private;
+    constructor(deps: TokenManagerDeps);
+    /** Current access token, obtaining or refreshing one if needed. */
+    getAccessToken(): Promise<string>;
+    /** Drop the cached token, but only if it is still the one that failed. */
+    invalidate(failedAccessToken: string): Promise<void>;
+    current(): Promise<Token | null>;
+    clear(): Promise<void>;
+}
+
+/**
+ * Transaction statuses returned in `data.status`. The SDK never throws based on
+ * these: a 2xx response with a success `code` is returned as-is. See
+ * https://developer.nomba.com/docs/api-basics/response-codes
+ */
+declare const TransactionStatus: {
+    /** Service delivered to the destination. Do not refund. */
+    readonly SUCCESS: "SUCCESS";
+    /** Still processing. Wait for the webhook or requery. */
+    readonly PENDING_BILLING: "PENDING_BILLING";
+    /** Still processing (v1 endpoints). Wait for the webhook or requery. */
+    readonly PROCESSING: "PROCESSING";
+    /** Funds returned to your Nomba wallet. Refund your customer. */
+    readonly REFUND: "REFUND";
+    /** The transaction will not proceed. Contact Nomba support. */
+    readonly CANCELLED: "CANCELLED";
+    /** Debit failed; Nomba may retry. Wait for the webhook. */
+    readonly PAYMENT_FAILED: "PAYMENT_FAILED";
+    /** Nomba may retry via another vendor. Wait for the webhook. */
+    readonly REVERSED_BY_VENDOR: "REVERSED_BY_VENDOR";
+};
+type TransactionStatus = (typeof TransactionStatus)[keyof typeof TransactionStatus];
+/** Webhook `event_type` values. */
+declare const WebhookEventType: {
+    readonly PAYMENT_SUCCESS: "payment_success";
+    readonly PAYMENT_FAILED: "payment_failed";
+    readonly PAYMENT_REVERSAL: "payment_reversal";
+    readonly PAYOUT_SUCCESS: "payout_success";
+    readonly PAYOUT_FAILED: "payout_failed";
+    readonly PAYOUT_REFUND: "payout_refund";
+};
+type WebhookEventType = (typeof WebhookEventType)[keyof typeof WebhookEventType];
+/** Envelope `code` values that mean success. */
+declare const SUCCESS_CODES: readonly ["00", "200", "201"];
+declare const BASE_URLS: {
+    readonly sandbox: "https://sandbox.nomba.com";
+    readonly production: "https://api.nomba.com";
+};
+type Environment = keyof typeof BASE_URLS;
+
+/**
+ * Error hierarchy.
+ *
+ * NombaError
+ * ├── ApiError                   2xx with a non-success `code`, or any HTTP error
+ * │   ├── AuthenticationError    401 after the token refresh retry, or token issue failed
+ * │   ├── PermissionDeniedError  403
+ * │   ├── NotFoundError          404
+ * │   ├── ValidationError        400, 422, and client-side validation
+ * │   ├── RateLimitError         429
+ * │   └── ServerError            5xx
+ * ├── ConnectionError            network failure
+ * │   └── TimeoutError           request timed out
+ * ├── WebhookVerificationError   webhook signature or payload rejected
+ * └── ConfigurationError         bad or missing client options
+ *
+ * Errors never carry credentials, tokens or request headers.
+ */
+/** The idempotency reference sent with a money-moving request. */
+interface ErrorReference {
+    /** Which request field held the reference. */
+    readonly field: "merchantTxRef" | "orderReference";
+    /** The value sent: yours, or the one the SDK generated. */
+    readonly value: string;
+}
+declare class NombaError extends Error {
+    /**
+     * Set on errors from money-moving calls (`transfers.toBank`, `transfers.toWallet`,
+     * `bills.*` purchases, `checkout.chargeSavedCard`). After a timeout or connection
+     * error, requery with this reference before retrying, and retry with the same one.
+     */
+    readonly reference: ErrorReference | undefined;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare class ConfigurationError extends NombaError {
+}
+declare class WebhookVerificationError extends NombaError {
+}
+declare class ConnectionError extends NombaError {
+    /** HTTP method of the failed request. */
+    readonly method: string | undefined;
+    /** Request path, without query string. */
+    readonly path: string | undefined;
+    constructor(message: string, options?: {
+        method?: string;
+        path?: string;
+        cause?: unknown;
+    });
+}
+declare class TimeoutError extends ConnectionError {
+}
+interface ApiErrorInit {
+    /** HTTP status, or `null` for client-side validation errors. */
+    httpStatus: number | null;
+    code?: string | undefined;
+    description?: string | undefined;
+    body?: unknown;
+    method?: string | undefined;
+    path?: string | undefined;
+}
+declare class ApiError extends NombaError {
+    /** HTTP status of the response, or `null` when the error was raised before sending. */
+    readonly httpStatus: number | null;
+    /** Nomba's `code` field from the response envelope, if present. */
+    readonly code: string | undefined;
+    /** Nomba's `description` (human-readable message), if present. */
+    readonly description: string | undefined;
+    /** Parsed response body. */
+    readonly body: unknown;
+    /** HTTP method of the request. */
+    readonly method: string | undefined;
+    /** Request path, without query string. */
+    readonly path: string | undefined;
+    constructor(init: ApiErrorInit, message?: string);
+    /** `Nomba API error 400 (code "400"): <description> [POST /v2/transfers/bank]` */
+    static formatMessage(init: ApiErrorInit): string;
+}
+declare class AuthenticationError extends ApiError {
+}
+declare class PermissionDeniedError extends ApiError {
+}
+declare class NotFoundError extends ApiError {
+}
+declare class ValidationError extends ApiError {
+    /** Client-side validation error: nothing was sent. */
+    static client(description: string): ValidationError;
+}
+interface RateLimitInfo {
+    /** `X-Rate-Limit-Limit`: requests allowed in the current window. */
+    limit?: string | undefined;
+    /** `X-Rate-Limit-Remaining`: requests left in the current window. */
+    remaining?: string | undefined;
+    /** `X-Rate-Limit-Window`: the window, e.g. `1s`. */
+    window?: string | undefined;
+}
+declare class RateLimitError extends ApiError {
+    /** Seconds to wait, from the `Retry-After` header, if present. */
+    readonly retryAfter: number | undefined;
+    /** `X-Rate-Limit-*` header values. */
+    readonly rateLimit: RateLimitInfo;
+    constructor(init: ApiErrorInit & {
+        retryAfter?: number;
+        rateLimit?: RateLimitInfo;
+    });
+}
+declare class ServerError extends ApiError {
+}
+
+type QueryValue = string | number | boolean | null | undefined;
+type Query = Record<string, QueryValue>;
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+interface RequestOptions {
+    method: HttpMethod;
+    /** Path starting with `/`, already validated and encoded. */
+    path: string;
+    query?: Query | undefined;
+    body?: unknown;
+    /**
+     * Token endpoint request:
+     * - `"obtain"` (issue/refresh): sent without a bearer token, retried like a GET,
+     *   and any 4xx other than 429 is an AuthenticationError.
+     * - `"revoke"`: an ordinary authenticated request.
+     * Both keep `data` out of error bodies, since it may hold tokens.
+     */
+    token?: "obtain" | "revoke";
+    /**
+     * Idempotency reference of a money-moving request: added to the returned data if
+     * missing, and attached to any error as `err.reference`.
+     */
+    reference?: ErrorReference;
+}
+interface HttpClientConfig {
+    baseUrl: string;
+    accountId: string;
+    timeout: number;
+    maxRetries: number;
+    fetch: typeof fetch;
+    userAgent: string;
+}
+declare class HttpClient {
+    #private;
+    constructor(config: HttpClientConfig);
+    setTokenManager(tokens: TokenManager): void;
+    /** Make a request and return the unwrapped `data` of a successful envelope. */
+    request<T>(opts: RequestOptions): Promise<T>;
+}
+
+interface ResourceContext {
+    http: HttpClient;
+    environment: "sandbox" | "production";
+}
+declare abstract class Resource {
+    protected readonly ctx: ResourceContext;
+    constructor(ctx: ResourceContext);
+    protected request<T>(opts: RequestOptions): Promise<T>;
+    /** `path` + `/{subAccountId}` (when given) + `suffix`. */
+    protected withSubAccount(path: string, subAccountId: string | undefined, suffix?: string): string;
+    /**
+     * Money-moving POST with a `merchantTxRef`: generate one if missing. The request
+     * layer returns it on the result and attaches it to any error.
+     */
+    protected withMerchantTxRef<T>(path: string, params: object, options?: SubAccountOption): Promise<T & {
+        merchantTxRef: string;
+    }>;
+}
+
+declare class Accounts extends Resource {
+    /** Parent account details. `GET /v1/accounts/parent` */
+    getParent(): Promise<Account>;
+    /** Balance of the parent account, or of a sub account. */
+    getBalance(params?: GetBalanceParams): Promise<Balance>;
+    /** Sub account details by `accountId` or `accountRef` (exactly one). */
+    getSubAccount(params: GetSubAccountParams): Promise<Account>;
+    /** One page of terminals on the parent account or a sub account. */
+    listTerminals(params?: ListTerminalsParams): Promise<CursorPage<Terminal>>;
+    /** Every terminal, across pages: `for await (const t of nomba.accounts.listAllTerminals())`. */
+    listAllTerminals(params?: Omit<ListTerminalsParams, "cursor">): AsyncGenerator<Terminal>;
+}
+
+declare class AuthResource extends Resource {
+    #private;
+    constructor(ctx: ResourceContext, tokens: TokenManager, clientId: string);
+    /**
+     * Revoke the cached access token (`POST /v1/auth/token/revoke`) and clear the
+     * token store. Does nothing and returns `null` when no token is cached.
+     */
+    revoke(): Promise<RevokeTokenResult | null>;
+}
+
+/**
+ * Bill payments. Purchases use the v2 endpoints, generate a `merchantTxRef` if
+ * you don't pass one, and are never retried automatically.
+ */
+declare class Bills extends Resource {
+    buyAirtime(params: BuyAirtimeParams, options?: SubAccountOption): Promise<BillPurchaseResult>;
+    buyData(params: BuyDataParams, options?: SubAccountOption): Promise<BillPurchaseResult>;
+    /** Data plans for a telco (e.g. `mtn`). The telco is lowercased. */
+    listDataPlans(telco: string): Promise<DataPlan[]>;
+    buyElectricity(params: BuyElectricityParams, options?: SubAccountOption): Promise<BillPurchaseResult>;
+    /** Electricity distribution companies (discos). */
+    listElectricityProviders(): Promise<unknown[]>;
+    lookupElectricityCustomer(params: LookupElectricityCustomerParams): Promise<ElectricityCustomer>;
+    payCableTv(params: PayCableTvParams, options?: SubAccountOption): Promise<BillPurchaseResult>;
+    listCableTvPlans(cableTvType: CableTvType): Promise<CableTvPlan[]>;
+    /** Returns the customer's name. */
+    lookupCableTvCustomer(params: LookupCableTvCustomerParams): Promise<string>;
+    fundBetting(params: FundBettingParams, options?: SubAccountOption): Promise<BillPurchaseResult>;
+    listBettingProviders(): Promise<BettingProvider[]>;
+    /** Returns the customer's name. */
+    lookupBettingCustomer(params: LookupBettingCustomerParams): Promise<string>;
+}
+
+declare class Checkout extends Resource {
+    /** Create a hosted checkout order and get its `checkoutLink`. */
+    createOrder(params: CreateOrderParams): Promise<CreateOrderResult>;
+    getOrder(orderReference: string): Promise<GetOrderResult>;
+    cancelOrder(params: OrderReferenceParams): Promise<SuccessMessage>;
+    /** A checkout transaction by order ID or order reference. */
+    getTransaction(params: GetCheckoutTransactionParams): Promise<CheckoutTransaction>;
+    /** Refund a checkout transaction. Never retried automatically. */
+    refund(params: RefundParams): Promise<SuccessMessage>;
+    /**
+     * Charge a saved (tokenized) card. This endpoint has no `merchantTxRef`; its
+     * reference is `order.orderReference`. If you omit it the SDK generates one
+     * (UUID v4) and returns it as `orderReference`. Never retried automatically.
+     */
+    chargeSavedCard(params: ChargeSavedCardParams): Promise<ChargeSavedCardResult>;
+    /** Saved cards, filtered by customer email and/or date range (page-numbered). */
+    listSavedCards(params?: ListSavedCardsParams): Promise<SavedCardList>;
+    updateSavedCardEmail(params: UpdateSavedCardEmailParams): Promise<UpdateSavedCardEmailResult>;
+    /** Delete a saved card. Sends a JSON body with DELETE. */
+    deleteSavedCard(params: DeleteSavedCardParams): Promise<StatusMessage>;
+    /** The bank account a customer can transfer to for this order. */
+    getTransferAccount(orderReference: string): Promise<TransferAccount>;
+    submitCardDetails(params: SubmitCardDetailsParams): Promise<SubmitCardDetailsResult>;
+    submitCardOtp(params: SubmitCardOtpParams): Promise<SubmitCardOtpResult>;
+    resendOtp(params: OrderReferenceParams): Promise<SuccessMessage>;
+    confirmTransactionReceipt(params: OrderReferenceParams): Promise<ConfirmTransactionReceiptResult>;
+    cancelTransaction(params: CancelTransactionParams): Promise<SuccessMessage>;
+    /** Send an OTP to a customer who wants to save their card. */
+    requestSaveCardOtp(params: RequestSaveCardOtpParams): Promise<SuccessMessage>;
+    /** Send an OTP to a customer who already has saved cards. */
+    requestSavedCardsOtp(params: OrderReferenceParams): Promise<SuccessMessage>;
+    submitUserOtp(params: SubmitUserOtpParams): Promise<SuccessMessage>;
+    /** The customer's saved cards for this order, after OTP verification. */
+    getSavedCards(orderReference: string, params: GetSavedCardsParams): Promise<UserSavedCards>;
+}
+
+declare class DirectDebits extends Resource {
+    createMandate(params: CreateMandateParams): Promise<CreateMandateResult>;
+    /** Debit a customer against an active mandate. Never retried automatically. */
+    debitMandate(params: DebitMandateParams): Promise<DebitMandateResult>;
+    getMandateStatus(mandateId: string): Promise<MandateStatus>;
+    listMandates(params?: ListMandatesParams): Promise<MandateList>;
+    updateMandateStatus(params: UpdateMandateStatusParams): Promise<UpdateMandateStatusResult>;
+}
+
+declare class GlobalCollection extends Resource {
+    /** Mobile-money providers for DRC inflows. */
+    listDrcProviders(): Promise<Provider[]>;
+    /** Start a mobile-money inflow. Never retried automatically. */
+    initiateInflow(params: InitiateInflowParams): Promise<InitiateInflowResult>;
+    getTransaction(transactionId: string): Promise<CollectionTransaction>;
+}
+
+/** Cross-border payouts. The sandbox uses separate paths for the account methods. */
+declare class GlobalPayout extends Resource {
+    #private;
+    listAccounts(): Promise<GlobalPayoutAccount[]>;
+    getAccount(accountId: string): Promise<GlobalPayoutAccount>;
+    listBankProviders(params?: ListBankProvidersParams): Promise<Provider[]>;
+    getExchangeRates(params: GetExchangeRatesParams): Promise<ExchangeRates>;
+    listPaymentMethods(params?: ListPaymentMethodsParams): Promise<PaymentMethod[]>;
+    getTransaction(transactionId: string): Promise<GlobalPayoutTransaction>;
+    /** Never retried automatically; pass an `idempotencyKey` and reuse it when retrying. */
+    authorizeExchange(params: AuthorizeExchangeParams): Promise<AuthorizeExchangeResult>;
+    convertMoney(params: ConvertMoneyParams): Promise<ConvertMoneyResult>;
+    /** Never retried automatically; pass an `idempotencyKey` and reuse it when retrying. */
+    authorizeTransfer(params: AuthorizeTransferParams): Promise<AuthorizeTransferResult>;
+}
+
+declare class Terminals extends Resource {
+    /** Assign a terminal to the parent account or a sub account. */
+    assign(params: AssignTerminalParams, options?: SubAccountOption): Promise<Terminal>;
+    /** Un-assign a terminal from the parent account or a sub account. */
+    unassign(params: AssignTerminalParams, options?: SubAccountOption): Promise<Terminal>;
+    /** Push a payment request to a terminal. */
+    sendPaymentRequest(terminalId: string, params: TerminalPaymentRequestParams): Promise<TerminalPaymentRequestResult>;
+}
+
+declare class Transactions extends Resource {
+    #private;
+    /** One page of transactions on the parent account or a sub account. */
+    list(params?: ListTransactionsParams): Promise<CursorPage<Transaction>>;
+    /** Every transaction, across pages: `for await (const tx of nomba.transactions.listAll())`. */
+    listAll(params?: Omit<ListTransactionsParams, "cursor">): AsyncGenerator<Transaction>;
+    /** One page of transactions matching `filters`. */
+    filter(filters?: TransactionFilters, params?: ListTransactionsParams): Promise<CursorPage<Transaction>>;
+    /** Every transaction matching `filters`, across pages. */
+    filterAll(filters?: TransactionFilters, params?: Omit<ListTransactionsParams, "cursor">): AsyncGenerator<Transaction>;
+    /** One transaction, by exactly one of `transactionRef`, `merchantTxRef`, `orderReference`, `orderId`. */
+    get(params: GetTransactionParams): Promise<Transaction>;
+    /** One page of credits/debits on the parent account. */
+    listBankTransactions(params?: ListBankTransactionsParams): Promise<CursorPage<BankTransaction>>;
+    /** Every credit/debit on the parent account, across pages. */
+    listAllBankTransactions(params?: Omit<ListBankTransactionsParams, "cursor">): AsyncGenerator<BankTransaction>;
+    /** Confirm a transaction's status by its NIP `sessionId`. */
+    requery(sessionId: string): Promise<Transaction>;
+}
+
+declare class Transfers extends Resource {
+    /** Bank codes and names. */
+    listBanks(): Promise<Bank[]>;
+    /** Resolve the account name for an account number and bank code. */
+    lookupAccount(params: LookupAccountParams): Promise<AccountLookupResult>;
+    /**
+     * Transfer to a bank account. Never retried automatically. Pass your own
+     * `merchantTxRef` (or keep the generated one from the result) to requery.
+     */
+    toBank(params: BankTransferParams, options?: SubAccountOption): Promise<BankTransferResult>;
+    /** Transfer to another Nomba wallet. Never retried automatically. */
+    toWallet(params: WalletTransferParams, options?: SubAccountOption): Promise<WalletTransferResult>;
+}
+
+declare class VirtualAccounts extends Resource {
+    /** Create a virtual account on the parent account or a sub account. */
+    create(params: CreateVirtualAccountParams, options?: SubAccountOption): Promise<VirtualAccount>;
+    /** Fetch a virtual account by its account reference or number. */
+    get(identifier: string): Promise<VirtualAccount>;
+    update(identifier: string, params: UpdateVirtualAccountParams): Promise<UpdateVirtualAccountResult>;
+    /** Expire (close) a virtual account. */
+    expire(identifier: string): Promise<ExpireVirtualAccountResult>;
+    /** One page of virtual accounts matching `filters`. */
+    list(filters?: VirtualAccountFilters, options?: PageOptions): Promise<CursorPage<VirtualAccount>>;
+    /** Every virtual account matching `filters`, across pages. */
+    listAll(filters?: VirtualAccountFilters, options?: Omit<PageOptions, "cursor">): AsyncGenerator<VirtualAccount>;
+}
+
+interface NombaOptions {
+    /** Defaults to env `NOMBA_CLIENT_ID`. */
+    clientId?: string;
+    /** Defaults to env `NOMBA_CLIENT_SECRET`. */
+    clientSecret?: string;
+    /** Parent account ID, sent as the `accountId` header. Defaults to env `NOMBA_ACCOUNT_ID`. */
+    accountId?: string;
+    /** `"sandbox"` (default) or `"production"`. Defaults to env `NOMBA_ENVIRONMENT`. */
+    environment?: Environment;
+    /** Override the API base URL (tests, proxies). Must be https unless the host is localhost. */
+    baseUrl?: string;
+    /** Per-request timeout in milliseconds. Default 30000. */
+    timeout?: number;
+    /** Automatic retries for GET and token requests. Default 2. POST/PUT/DELETE are never retried. */
+    maxRetries?: number;
+    /** Where to keep the access token. Default: in memory. */
+    tokenStore?: TokenStore;
+    /** Custom `fetch` implementation. Default: the global `fetch`. */
+    fetch?: typeof fetch;
+}
+/**
+ * Nomba API client.
+ *
+ * ```ts
+ * const nomba = new Nomba(); // reads NOMBA_CLIENT_ID, NOMBA_CLIENT_SECRET, NOMBA_ACCOUNT_ID
+ * const balance = await nomba.accounts.getBalance();
+ * ```
+ */
+declare class Nomba {
+    #private;
+    /** Webhook verification without a client: `Nomba.webhooks.verify(rawBody, headers, key)`. */
+    static readonly webhooks: {
+        readonly verify: typeof verifyWebhook;
+        readonly computeSignature: typeof computeWebhookSignature;
+    };
+    static readonly VERSION = "0.1.0";
+    readonly environment: Environment;
+    readonly baseUrl: string;
+    readonly accountId: string;
+    readonly auth: AuthResource;
+    readonly accounts: Accounts;
+    readonly virtualAccounts: VirtualAccounts;
+    readonly checkout: Checkout;
+    readonly transfers: Transfers;
+    readonly transactions: Transactions;
+    readonly terminals: Terminals;
+    readonly directDebits: DirectDebits;
+    readonly bills: Bills;
+    readonly globalPayout: GlobalPayout;
+    readonly globalCollection: GlobalCollection;
+    readonly webhooks: {
+        readonly verify: typeof verifyWebhook;
+        readonly computeSignature: typeof computeWebhookSignature;
+    };
+    constructor(options?: NombaOptions);
+    /** Safe summary: never includes the client secret or tokens. */
+    toJSON(): Record<string, string>;
+}
+
+/** SDK version. Kept in sync with package.json (checked by a unit test). */
+declare const VERSION = "0.1.0";
+
+export { type Account, type AccountLookupResult, ApiError, type ApiErrorInit, type AssignTerminalParams, AuthenticationError, type AuthorizeExchangeParams, type AuthorizeExchangeResult, type AuthorizeTransferParams, type AuthorizeTransferResult, BASE_URLS, type Balance, type Bank, type BankTransaction, type BankTransferParams, type BankTransferResult, type BettingProvider, type BillPurchaseResult, type BuyAirtimeParams, type BuyDataParams, type BuyElectricityParams, type CableTvPlan, type CableTvType, type CancelTransactionParams, type ChargeSavedCardParams, type ChargeSavedCardResult, type CheckoutCurrency, type CheckoutOrder, type CheckoutOrderInput, type CheckoutTransaction, type CollectionTransaction, ConfigurationError, type ConfirmTransactionReceiptResult, ConnectionError, type ConvertMoneyParams, type ConvertMoneyResult, type CreateMandateParams, type CreateMandateResult, type CreateOrderParams, type CreateOrderResult, type CreateVirtualAccountParams, type CursorPage, type DataPlan, type DateRange, type DebitMandateParams, type DebitMandateResult, type DeleteSavedCardParams, type DeviceInformation, type ElectricityCustomer, type Environment, type ErrorReference, type ExchangeRates, type ExpireVirtualAccountResult, type Extra, type FundBettingParams, type GetBalanceParams, type GetCheckoutTransactionParams, type GetExchangeRatesParams, type GetOrderResult, type GetSavedCardsParams, type GetSubAccountParams, type GetTransactionParams, type GlobalPayoutAccount, type GlobalPayoutTransaction, InMemoryTokenStore, type InitiateInflowParams, type InitiateInflowResult, type ListBankProvidersParams, type ListBankTransactionsParams, type ListMandatesParams, type ListPaymentMethodsParams, type ListSavedCardsParams, type ListTerminalsParams, type ListTransactionsParams, type LookupAccountParams, type LookupBettingCustomerParams, type LookupCableTvCustomerParams, type LookupElectricityCustomerParams, type Mandate, type MandateFrequency, type MandateList, type MandateStatus, type MerchantTxRefOption, type Network, Nomba, NombaError, type NombaOptions, NotFoundError, type OrderReferenceParams, type PageOptions, type PayCableTvParams, type PaymentMethod, PermissionDeniedError, type Provider, RateLimitError, type RateLimitInfo, type RefundParams, type RequestSaveCardOtpParams, type RevokeTokenResult, SUCCESS_CODES, type SavedCard, type SavedCardList, ServerError, type SplitRequest, type StatusMessage, type SubAccountOption, type SubmitCardDetailsParams, type SubmitCardDetailsResult, type SubmitCardOtpParams, type SubmitCardOtpResult, type SubmitUserOtpParams, type SuccessMessage, type Terminal, type TerminalPaymentRequestParams, type TerminalPaymentRequestResult, TimeoutError, type Token, type TokenStore, type Transaction, type TransactionFilters, type TransactionSource, TransactionStatus, type TransactionStatusValue, type TransactionType, type TransferAccount, type UpdateMandateStatusParams, type UpdateMandateStatusResult, type UpdateSavedCardEmailParams, type UpdateSavedCardEmailResult, type UpdateVirtualAccountParams, type UpdateVirtualAccountResult, type UserSavedCards, VERSION, ValidationError, type VerifyWebhookOptions, type VirtualAccount, type VirtualAccountFilters, type WalletTransferParams, type WalletTransferResult, type WebhookEvent, WebhookEventType, type WebhookHeaders, WebhookVerificationError, computeWebhookSignature, Nomba as default, verifyWebhook };