@laranex/myanmar-payments 0.0.0-stage → 4.0.0-dev.1

package/dist/cjs/kbz-pay/kbz-pay.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KbzPay = exports.KbzPayConfig = void 0;
+const callback_js_1 = require("../core/callback.js");
+const crypto_js_1 = require("../core/crypto.js");
+const env_js_1 = require("../core/env.js");
+const errors_js_1 = require("../core/errors.js");
+const http_js_1 = require("../core/http.js");
+const json_js_1 = require("../core/json.js");
+const results_js_1 = require("../core/results.js");
+const status_js_1 = require("../core/status.js");
+const validate_js_1 = require("../core/validate.js");
+const values_js_1 = require("../core/values.js");
+const signer_js_1 = require("./signer.js");
+/**
+ * KBZ Pay credentials and endpoints. A missing credential throws a `ConfigurationError`.
+ */
+class KbzPayConfig {
+    static SANDBOX_API_URL = 'http://api-uat.kbzpay.com/payment/gateway/uat';
+    static PRODUCTION_API_URL = 'https://api.kbzpay.com/payment/gateway';
+    static SANDBOX_PWA_URL = 'https://static.kbzpay.com/pgw/uat/pwa/#/';
+    static PRODUCTION_PWA_URL = 'https://wap.kbzpay.com/pgw/pwa/#/';
+    appId;
+    appKey;
+    merchantCode;
+    sandbox;
+    /** The API base URL in use. */
+    apiUrl;
+    /** The PWA checkout URL in use, always ending in `/`. */
+    pwaUrl;
+    constructor(options) {
+        this.appId = (0, env_js_1.requireSetting)('kbz_pay', 'app_id', options.appId);
+        this.appKey = (0, env_js_1.requireSetting)('kbz_pay', 'app_key', options.appKey);
+        this.merchantCode = (0, env_js_1.requireSetting)('kbz_pay', 'merchant_code', options.merchantCode);
+        this.sandbox = options.sandbox ?? true;
+        this.apiUrl = (0, env_js_1.trimUrl)((0, env_js_1.optionalSetting)(options.apiUrl) ??
+            (this.sandbox ? KbzPayConfig.SANDBOX_API_URL : KbzPayConfig.PRODUCTION_API_URL));
+        this.pwaUrl = `${(0, env_js_1.trimUrl)((0, env_js_1.optionalSetting)(options.pwaUrl) ??
+            (this.sandbox ? KbzPayConfig.SANDBOX_PWA_URL : KbzPayConfig.PRODUCTION_PWA_URL))}/`;
+    }
+    /**
+     * Reads `KBZ_PAY_APP_ID`, `KBZ_PAY_APP_KEY`, `KBZ_PAY_MERCHANT_CODE`, `KBZ_PAY_SANDBOX`,
+     * `KBZ_PAY_BASE_URL` and `KBZ_PAY_PWA_BASE_REDIRECT_URL`.
+     */
+    static fromEnv(env = (0, env_js_1.defaultEnv)()) {
+        return new KbzPayConfig({
+            appId: (0, env_js_1.envFirst)(env, 'KBZ_PAY_APP_ID'),
+            appKey: (0, env_js_1.envFirst)(env, 'KBZ_PAY_APP_KEY'),
+            merchantCode: (0, env_js_1.envFirst)(env, 'KBZ_PAY_MERCHANT_CODE'),
+            sandbox: (0, env_js_1.envSandbox)(env, 'KBZ_PAY_SANDBOX'),
+            apiUrl: (0, env_js_1.envFirst)(env, 'KBZ_PAY_BASE_URL'),
+            pwaUrl: (0, env_js_1.envFirst)(env, 'KBZ_PAY_PWA_BASE_REDIRECT_URL'),
+        });
+    }
+}
+exports.KbzPayConfig = KbzPayConfig;
+const ORDER_ID = /^[A-Za-z0-9_]+$/;
+const STATUSES = {
+    PAY_SUCCESS: 'successful',
+    WAIT_PAY: 'pending',
+    PAYING: 'pending',
+    PAY_FAILED: 'failed',
+    ORDER_CLOSED: 'cancelled',
+    ORDER_EXPIRED: 'expired',
+};
+/**
+ * KBZ Pay: PWA (redirect), QR and in-app payments, order status queries and payment
+ * notifications.
+ */
+class KbzPay {
+    /** The configuration in use. */
+    config;
+    /** KBZ Pay's request signer, for custom calls. */
+    signer;
+    transport;
+    constructor(config, options = {}) {
+        this.config = config instanceof KbzPayConfig ? config : new KbzPayConfig(config);
+        this.signer = new signer_js_1.KbzPaySigner(this.config.appKey);
+        this.transport = new http_js_1.Transport((0, http_js_1.httpClientFrom)(options));
+    }
+    /** A gateway configured from the `KBZ_PAY_*` environment variables. */
+    static fromEnv(env = (0, env_js_1.defaultEnv)(), options = {}) {
+        return new KbzPay(KbzPayConfig.fromEnv(env), options);
+    }
+    /** Checks the order against KBZ's documented limits; throws an `InvalidPaymentDataError`. */
+    static validate(data) {
+        const callbackUrl = typeof data.callbackUrl === 'string' ? data.callbackUrl : '';
+        new validate_js_1.Validator()
+            .required('orderId', data.orderId)
+            .max('orderId', data.orderId, 40)
+            .pattern('orderId', data.orderId, ORDER_ID, 'letters, numbers and underscores')
+            .amount('amount', data.amount, { gateway: 'KBZ Pay', maxDecimals: 2 })
+            .required('callbackUrl', data.callbackUrl)
+            .url('callbackUrl', callbackUrl)
+            .max('callbackUrl', callbackUrl, 512)
+            .when(callbackUrl.includes('?'), 'callbackUrl', 'The callbackUrl field must not contain a query string.')
+            .string('title', data.title)
+            .between('timeoutMinutes', data.timeoutMinutes, 1, 120)
+            .string('callbackInfo', data.callbackInfo)
+            .max('callbackInfo', typeof data.callbackInfo === 'string' ? (0, crypto_js_1.queryEscape)(data.callbackInfo) : undefined, 512)
+            .validate();
+    }
+    /**
+     * Creates an order and returns the KBZ Pay PWA checkout URL to redirect the customer to.
+     *
+     * The redirect only works on a phone with the KBZ Pay app installed, and its Referer must match
+     * the URL registered with KBZ.
+     */
+    async pwa(data, options = {}) {
+        const order = await this.precreate(data, 'PWAAPP', options);
+        const fields = this.orderInfoFields(order);
+        return new results_js_1.RedirectPayment({
+            orderId: data.orderId,
+            url: `${this.config.pwaUrl}?${this.signer.signString(fields)}&sign=${this.signer.sign(fields)}`,
+            gatewayReference: order.prepayId,
+            raw: (0, json_js_1.toPlainObject)(order.response),
+        });
+    }
+    /** Creates an order and returns a QR payload for the customer to scan with the KBZ Pay app. */
+    async qr(data, options = {}) {
+        const order = await this.precreate(data, 'PAY_BY_QRCODE', options);
+        const qrCode = (0, values_js_1.get)(order.response, 'qrCode');
+        if (qrCode === '') {
+            throw new errors_js_1.ApiError('KBZ Pay did not return a QR code.', {
+                raw: (0, json_js_1.toPlainObject)(order.response),
+            });
+        }
+        return new results_js_1.QrPayment({
+            orderId: data.orderId,
+            qrString: qrCode,
+            expiresAt: data.timeoutMinutes === undefined
+                ? undefined
+                : new Date(Date.now() + data.timeoutMinutes * 60_000),
+            reference: order.prepayId,
+            raw: (0, json_js_1.toPlainObject)(order.response),
+        });
+    }
+    /**
+     * Creates an order and returns the signed values your mobile app passes to `KBZPay.startPay()`.
+     * The SDK's own result only means the payment screen closed; rely on the callback or `status()`.
+     */
+    async app(data, options = {}) {
+        const order = await this.precreate(data, 'APP', options);
+        const fields = this.orderInfoFields(order);
+        return new results_js_1.AppPayment({
+            orderId: data.orderId,
+            orderInfo: this.signer.signString(fields),
+            sign: this.signer.sign(fields),
+            signType: 'SHA256',
+            raw: (0, json_js_1.toPlainObject)(order.response),
+        });
+    }
+    /** Asks KBZ Pay for the current state of an order (`queryorder`). */
+    async status(orderId, options = {}) {
+        const response = await this.call('queryorder', 'kbz.payment.queryorder', '3.0', {
+            appid: this.config.appId,
+            merch_code: this.config.merchantCode,
+            merch_order_id: orderId,
+        }, {}, (0, crypto_js_1.randomHex)(), timestamp(), options.signal);
+        const tradeStatus = (0, values_js_1.trimmed)(response, 'trade_status');
+        return new callback_js_1.PaymentStatusResult({
+            orderId: (0, values_js_1.optional)(response, 'merch_order_id') || orderId,
+            status: (0, status_js_1.resolveStatus)(STATUSES, tradeStatus),
+            gatewayStatus: tradeStatus,
+            gatewayReference: (0, values_js_1.optional)(response, 'mm_order_id'),
+            amount: (0, values_js_1.optional)(response, 'total_amount'),
+            raw: (0, json_js_1.toPlainObject)(response),
+        });
+    }
+    /**
+     * Verifies KBZ Pay's payment notification. Reply with the callback's `acknowledgement` (plain
+     * `success`) or KBZ retries.
+     */
+    handleCallback(request) {
+        const input = (0, callback_js_1.losslessBody)(request);
+        const fields = (0, values_js_1.object)(input, 'Request') ?? input;
+        if (!this.signer.verify(fields)) {
+            throw new errors_js_1.SignatureVerificationError('KBZ Pay callback signature verification failed.', (0, json_js_1.toPlainObject)(input));
+        }
+        const tradeStatus = (0, values_js_1.trimmed)(fields, 'trade_status');
+        return new callback_js_1.PaymentCallback({
+            orderId: (0, values_js_1.get)(fields, 'merch_order_id'),
+            status: (0, status_js_1.resolveStatus)(STATUSES, tradeStatus),
+            gatewayStatus: tradeStatus,
+            gatewayReference: (0, values_js_1.optional)(fields, 'mm_order_id'),
+            amount: (0, values_js_1.optional)(fields, 'total_amount'),
+            raw: (0, json_js_1.toPlainObject)(fields),
+            acknowledgement: new callback_js_1.Acknowledgement({ body: 'success' }),
+        });
+    }
+    async precreate(data, tradeType, options) {
+        KbzPay.validate(data);
+        const biz = {
+            appid: this.config.appId,
+            merch_code: this.config.merchantCode,
+            merch_order_id: data.orderId,
+            trade_type: tradeType,
+            total_amount: String((0, validate_js_1.toAmount)(data.amount)),
+            trans_currency: 'MMK',
+        };
+        if (data.title) {
+            biz.title = data.title;
+        }
+        if (data.timeoutMinutes !== undefined) {
+            biz.timeout_express = `${data.timeoutMinutes}m`;
+        }
+        if (data.callbackInfo) {
+            biz.callback_info = (0, crypto_js_1.queryEscape)(data.callbackInfo);
+        }
+        const nonce = (0, crypto_js_1.randomHex)();
+        const time = timestamp();
+        const response = await this.call('precreate', 'kbz.payment.precreate', '1.0', biz, { notify_url: data.callbackUrl }, nonce, time, options.signal);
+        const prepayId = (0, values_js_1.get)(response, 'prepay_id');
+        if (prepayId === '') {
+            throw new errors_js_1.ApiError('KBZ Pay did not return a prepay_id.', { raw: (0, json_js_1.toPlainObject)(response) });
+        }
+        return { prepayId, nonce, timestamp: time, response };
+    }
+    /** Sends a signed request and returns the `Response` object, throwing when KBZ reports an error. */
+    async call(endpoint, method, version, biz, extra, nonce, time, signal) {
+        const common = {
+            timestamp: time,
+            method,
+            nonce_str: nonce,
+            version,
+            ...extra,
+        };
+        const request = {
+            ...common,
+            sign_type: 'SHA256',
+            sign: this.signer.sign({ ...common, ...biz }),
+            biz_content: biz,
+        };
+        const response = await this.transport.postJson(`${this.config.apiUrl}/${endpoint}`, { Request: request }, {}, signal);
+        const body = response.json();
+        const result = (0, values_js_1.object)(body, 'Response') ?? {};
+        if (!response.successful() ||
+            (0, values_js_1.get)(result, 'result') !== 'SUCCESS' ||
+            (0, values_js_1.get)(result, 'code') !== '0') {
+            const code = (0, values_js_1.optional)(result, 'code');
+            const message = (0, values_js_1.optional)(result, 'msg');
+            throw new errors_js_1.ApiError(code
+                ? `KBZ Pay ${endpoint} failed: [${code}] ${message ?? ''}`.trimEnd()
+                : `KBZ Pay ${endpoint} failed with HTTP ${response.status}.`, {
+                gatewayCode: code,
+                gatewayMessage: message,
+                httpStatus: response.status,
+                raw: (0, json_js_1.toPlainObject)(body),
+            });
+        }
+        return result;
+    }
+    orderInfoFields(order) {
+        return {
+            appid: this.config.appId,
+            merch_code: this.config.merchantCode,
+            nonce_str: order.nonce,
+            prepay_id: order.prepayId,
+            timestamp: order.timestamp,
+        };
+    }
+}
+exports.KbzPay = KbzPay;
+function timestamp() {
+    return String(Math.floor(Date.now() / 1000));
+}

package/dist/cjs/kbz-pay/signer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * KBZ Pay's signature: every non-empty scalar field except `sign` and `sign_type`, sorted by key,
+ * joined as raw `key=value` pairs (not URL-encoded), with `&key=<app key>` appended, hashed with
+ * SHA-256 and uppercased.
+ */
+export declare class KbzPaySigner {
+    private readonly appKey;
+    constructor(appKey: string);
+    /** The sorted `key=value` string, without the app key. */
+    signString(fields: Readonly<Record<string, unknown>>): string;
+    /** The uppercase SHA-256 signature of `fields`. */
+    sign(fields: Readonly<Record<string, unknown>>): string;
+    /** Whether `fields.sign` matches, compared in constant time. */
+    verify(fields: Readonly<Record<string, unknown>>): boolean;
+}

package/dist/cjs/kbz-pay/signer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KbzPaySigner = void 0;
+const crypto_js_1 = require("../core/crypto.js");
+const values_js_1 = require("../core/values.js");
+/**
+ * KBZ Pay's signature: every non-empty scalar field except `sign` and `sign_type`, sorted by key,
+ * joined as raw `key=value` pairs (not URL-encoded), with `&key=<app key>` appended, hashed with
+ * SHA-256 and uppercased.
+ */
+class KbzPaySigner {
+    appKey;
+    constructor(appKey) {
+        this.appKey = appKey;
+    }
+    /** The sorted `key=value` string, without the app key. */
+    signString(fields) {
+        return Object.keys(fields)
+            .filter((key) => key !== 'sign' && key !== 'sign_type')
+            .map((key) => [key, (0, values_js_1.scalarString)(fields[key])])
+            .filter((pair) => pair[1] !== undefined && pair[1] !== '')
+            .sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+    }
+    /** The uppercase SHA-256 signature of `fields`. */
+    sign(fields) {
+        return (0, crypto_js_1.sha256Hex)(`${this.signString(fields)}&key=${this.appKey}`).toUpperCase();
+    }
+    /** Whether `fields.sign` matches, compared in constant time. */
+    verify(fields) {
+        const sign = fields.sign;
+        return typeof sign === 'string' && (0, crypto_js_1.safeEqual)(this.sign(fields), sign.toUpperCase());
+    }
+}
+exports.KbzPaySigner = KbzPaySigner;

package/dist/cjs/myanmar-payments.d.ts

@@ -0,0 +1,50 @@
+import { AyaPay, AyaPayConfig, type AyaPayConfigOptions } from './aya-pay/aya-pay.js';
+import type { TokenCache } from './core/cache.js';
+import { type EnvSource } from './core/env.js';
+import type { GatewayOptions } from './core/http.js';
+import { CyberSource, CyberSourceConfig, type CyberSourceConfigOptions } from './cyber-source/cyber-source.js';
+import { KbzPay, KbzPayConfig, type KbzPayConfigOptions } from './kbz-pay/kbz-pay.js';
+import { WaveMoney, WaveMoneyConfig, type WaveMoneyConfigOptions } from './wave-money/wave-money.js';
+import { YomaMmqr, YomaMmqrConfig, type YomaMmqrConfigOptions } from './yoma-mmqr/yoma-mmqr.js';
+/** The configuration of every gateway; configure only the ones you use. */
+export interface MyanmarPaymentsConfig {
+    kbzPay?: KbzPayConfig | KbzPayConfigOptions | undefined;
+    waveMoney?: WaveMoneyConfig | WaveMoneyConfigOptions | undefined;
+    ayaPay?: AyaPayConfig | AyaPayConfigOptions | undefined;
+    yomaMmqr?: YomaMmqrConfig | YomaMmqrConfigOptions | undefined;
+    cyberSource?: CyberSourceConfig | CyberSourceConfigOptions | undefined;
+}
+/** Options shared by every gateway the facade builds. */
+export interface MyanmarPaymentsOptions extends GatewayOptions {
+    /** Keeps Yoma MMQR's access token; defaults to a {@link MemoryTokenCache}. */
+    tokenCache?: TokenCache | undefined;
+}
+/**
+ * Builds each gateway from one configuration object (or the environment). Gateways are created
+ * on first use and reused, so only the gateways you call need to be configured.
+ */
+export declare class MyanmarPayments {
+    private kbzPayGateway;
+    private waveMoneyGateway;
+    private ayaPayGateway;
+    private yomaMmqrGateway;
+    private cyberSourceGateway;
+    private readonly options;
+    private readonly sources;
+    constructor(config?: MyanmarPaymentsConfig, options?: MyanmarPaymentsOptions);
+    /**
+     * Reads every gateway's configuration from environment variables (`KBZ_PAY_*`, `WAVE_MONEY_*`,
+     * `AYA_PAY_*`, `YOMA_MMQR_*`, `CYBER_SOURCE_*`) when the gateway is first used.
+     */
+    static fromEnv(env?: EnvSource, options?: MyanmarPaymentsOptions): MyanmarPayments;
+    /** The KBZ Pay gateway. Throws a `ConfigurationError` when it is not configured. */
+    kbzPay(): KbzPay;
+    /** The Wave Money gateway. Throws a `ConfigurationError` when it is not configured. */
+    waveMoney(): WaveMoney;
+    /** The AYA Payment Gateway. Throws a `ConfigurationError` when it is not configured. */
+    ayaPay(): AyaPay;
+    /** The Yoma MMQR gateway. Throws a `ConfigurationError` when it is not configured. */
+    yomaMmqr(): YomaMmqr;
+    /** The CyberSource gateway. Throws a `ConfigurationError` when it is not configured. */
+    cyberSource(): CyberSource;
+}

package/dist/cjs/myanmar-payments.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyanmarPayments = void 0;
+const aya_pay_js_1 = require("./aya-pay/aya-pay.js");
+const cache_js_1 = require("./core/cache.js");
+const env_js_1 = require("./core/env.js");
+const errors_js_1 = require("./core/errors.js");
+const cyber_source_js_1 = require("./cyber-source/cyber-source.js");
+const kbz_pay_js_1 = require("./kbz-pay/kbz-pay.js");
+const wave_money_js_1 = require("./wave-money/wave-money.js");
+const yoma_mmqr_js_1 = require("./yoma-mmqr/yoma-mmqr.js");
+/**
+ * Builds each gateway from one configuration object (or the environment). Gateways are created
+ * on first use and reused, so only the gateways you call need to be configured.
+ */
+class MyanmarPayments {
+    kbzPayGateway;
+    waveMoneyGateway;
+    ayaPayGateway;
+    yomaMmqrGateway;
+    cyberSourceGateway;
+    options;
+    sources;
+    constructor(config = {}, options = {}) {
+        this.options = { ...options, tokenCache: options.tokenCache ?? new cache_js_1.MemoryTokenCache() };
+        this.sources = { ...config };
+    }
+    /**
+     * Reads every gateway's configuration from environment variables (`KBZ_PAY_*`, `WAVE_MONEY_*`,
+     * `AYA_PAY_*`, `YOMA_MMQR_*`, `CYBER_SOURCE_*`) when the gateway is first used.
+     */
+    static fromEnv(env = (0, env_js_1.defaultEnv)(), options = {}) {
+        const payments = new MyanmarPayments({}, options);
+        Object.assign(payments.sources, {
+            kbzPay: () => kbz_pay_js_1.KbzPayConfig.fromEnv(env),
+            waveMoney: () => wave_money_js_1.WaveMoneyConfig.fromEnv(env),
+            ayaPay: () => aya_pay_js_1.AyaPayConfig.fromEnv(env),
+            yomaMmqr: () => yoma_mmqr_js_1.YomaMmqrConfig.fromEnv(env),
+            cyberSource: () => cyber_source_js_1.CyberSourceConfig.fromEnv(env),
+        });
+        return payments;
+    }
+    /** The KBZ Pay gateway. Throws a `ConfigurationError` when it is not configured. */
+    kbzPay() {
+        return (this.kbzPayGateway ??= new kbz_pay_js_1.KbzPay(resolve(this.sources.kbzPay, kbz_pay_js_1.KbzPayConfig, 'kbz_pay', 'app_id'), this.options));
+    }
+    /** The Wave Money gateway. Throws a `ConfigurationError` when it is not configured. */
+    waveMoney() {
+        return (this.waveMoneyGateway ??= new wave_money_js_1.WaveMoney(resolve(this.sources.waveMoney, wave_money_js_1.WaveMoneyConfig, 'wave_money', 'merchant_id'), this.options));
+    }
+    /** The AYA Payment Gateway. Throws a `ConfigurationError` when it is not configured. */
+    ayaPay() {
+        return (this.ayaPayGateway ??= new aya_pay_js_1.AyaPay(resolve(this.sources.ayaPay, aya_pay_js_1.AyaPayConfig, 'aya_pay', 'app_key'), this.options));
+    }
+    /** The Yoma MMQR gateway. Throws a `ConfigurationError` when it is not configured. */
+    yomaMmqr() {
+        return (this.yomaMmqrGateway ??= new yoma_mmqr_js_1.YomaMmqr(resolve(this.sources.yomaMmqr, yoma_mmqr_js_1.YomaMmqrConfig, 'yoma_mmqr', 'merchant_id'), this.options));
+    }
+    /** The CyberSource gateway. Throws a `ConfigurationError` when it is not configured. */
+    cyberSource() {
+        return (this.cyberSourceGateway ??= new cyber_source_js_1.CyberSource(resolve(this.sources.cyberSource, cyber_source_js_1.CyberSourceConfig, 'cyber_source', 'profile_id')));
+    }
+}
+exports.MyanmarPayments = MyanmarPayments;
+function resolve(source, type, gateway, firstKey) {
+    if (source === undefined || source === null) {
+        throw new errors_js_1.ConfigurationError(gateway, firstKey);
+    }
+    if (typeof source === 'function') {
+        return source();
+    }
+    return source instanceof type ? source : new type(source);
+}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/wave-money/index.d.ts

@@ -0,0 +1 @@
+export { WaveMoney, WaveMoneyConfig, type WaveMoneyConfigOptions, type WaveMoneyItem, type WaveMoneyPaymentData, } from './wave-money.js';

package/dist/cjs/wave-money/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveMoneyConfig = exports.WaveMoney = void 0;
+var wave_money_js_1 = require("./wave-money.js");
+Object.defineProperty(exports, "WaveMoney", { enumerable: true, get: function () { return wave_money_js_1.WaveMoney; } });
+Object.defineProperty(exports, "WaveMoneyConfig", { enumerable: true, get: function () { return wave_money_js_1.WaveMoneyConfig; } });

package/dist/cjs/wave-money/wave-money.d.ts

@@ -0,0 +1,111 @@
+import { Amount, type AmountInput } from '../core/amount.js';
+import { CallbackRequest, PaymentCallback } from '../core/callback.js';
+import { type EnvSource } from '../core/env.js';
+import { type GatewayOptions, type RequestOptions } from '../core/http.js';
+import { RedirectPayment } from '../core/results.js';
+/** The settings of {@link WaveMoneyConfig}. */
+export interface WaveMoneyConfigOptions {
+    /** The merchant id Wave issued. */
+    merchantId: string;
+    /** The hash secret key Wave issued. */
+    secretKey: string;
+    /** Your business name, shown on Wave's payment page. */
+    merchantName: string;
+    /** How long the customer has to pay, in seconds (default 300). */
+    timeToLiveSeconds?: number | undefined;
+    /** Use the test environment (default `true`). */
+    sandbox?: boolean | undefined;
+    /** Overrides the API base URL. */
+    baseUrl?: string | undefined;
+    /** Overrides the host the customer is redirected to. Wave serves it without the API port. */
+    authenticateUrl?: string | undefined;
+}
+/**
+ * Wave Money credentials and endpoints. A missing credential throws a `ConfigurationError`.
+ */
+export declare class WaveMoneyConfig {
+    static readonly SANDBOX_URL = "https://preprodpayments.wavemoney.io:8107";
+    static readonly PRODUCTION_URL = "https://payments.wavemoney.io";
+    static readonly SANDBOX_AUTHENTICATE_URL = "https://preprodpayments.wavemoney.io";
+    static readonly PRODUCTION_AUTHENTICATE_URL = "https://payments.wavemoney.io";
+    static readonly DEFAULT_TIME_TO_LIVE_SECONDS = 300;
+    readonly merchantId: string;
+    readonly secretKey: string;
+    readonly merchantName: string;
+    /** Seconds the customer has to pay. */
+    readonly timeToLiveSeconds: number;
+    readonly sandbox: boolean;
+    /** The API base URL in use. */
+    readonly baseUrl: string;
+    /** The host the customer is redirected to. */
+    readonly authenticateUrl: string;
+    constructor(options: WaveMoneyConfigOptions);
+    /**
+     * Reads `WAVE_MONEY_MERCHANT_ID`, `WAVE_MONEY_SECRET_KEY`, `WAVE_MONEY_MERCHANT_NAME` (falling back
+     * to `APP_NAME`), `WAVE_MONEY_TIME_TO_LIVE_IN_SECONDS`, `WAVE_MONEY_SANDBOX`, `WAVE_MONEY_BASE_URL`
+     * and `WAVE_MONEY_AUTHENTICATE_URL`.
+     */
+    static fromEnv(env?: EnvSource): WaveMoneyConfig;
+}
+/** A line item shown on Wave's payment page. */
+export interface WaveMoneyItem {
+    /** The item name. */
+    name: string;
+    /** The item amount in whole kyat, e.g. `Amount.kyat(1000)` or `1000`. */
+    amount: AmountInput;
+}
+/**
+ * A Wave Money payment request. Wave only accepts whole kyat (MMK).
+ */
+export interface WaveMoneyPaymentData {
+    /** Your order id. One order can have several payment attempts. */
+    orderId: string;
+    /** The URL Wave posts the result to (`backend_result_url`). */
+    callbackUrl: string;
+    /** Where Wave sends the customer back (`frontend_result_url`). Not proof of payment. */
+    returnUrl: string;
+    /** Shown to the customer. */
+    description: string;
+    /** The line items shown on Wave's page; at least one. */
+    items: readonly WaveMoneyItem[];
+    /** The total in whole kyat. Leave it unset to charge the sum of the items. */
+    amount?: AmountInput | undefined;
+    /**
+     * The unique id of this attempt; Wave rejects a reused one. `initiate()` fills it with a random
+     * id when empty, so store it afterwards: Wave's callback may omit `orderId` but always carries
+     * this.
+     */
+    merchantReferenceId?: string | undefined;
+}
+/**
+ * Wave Money (WavePay payment gateway): redirect payments and callbacks. Wave has no status API,
+ * so the callback is the only result.
+ */
+export declare class WaveMoney {
+    /** The configuration in use. */
+    readonly config: WaveMoneyConfig;
+    private readonly transport;
+    constructor(config: WaveMoneyConfig | WaveMoneyConfigOptions, options?: GatewayOptions);
+    /** A gateway configured from the `WAVE_MONEY_*` environment variables. */
+    static fromEnv(env?: EnvSource, options?: GatewayOptions): WaveMoney;
+    /**
+     * The total that will be charged: `amount`, or the exact sum of the items when it is unset.
+     * `undefined` when an item amount is missing, malformed or has decimals.
+     */
+    static resolvedAmount(data: Pick<WaveMoneyPaymentData, 'amount' | 'items'>): Amount | undefined;
+    /** Checks the request against Wave's documented rules; throws an `InvalidPaymentDataError`. */
+    static validate(data: WaveMoneyPaymentData): void;
+    /**
+     * Creates a payment request and returns Wave's page to redirect the customer to. Once `data`
+     * passes validation it fills `data.merchantReferenceId` with a random id when empty, so store it
+     * afterwards. Invalid data is left untouched.
+     */
+    initiate(data: WaveMoneyPaymentData, options?: RequestOptions): Promise<RedirectPayment>;
+    /**
+     * Verifies Wave's callback. Only `PAYMENT_CONFIRMED` means the customer paid. `orderId` falls
+     * back to `merchantReferenceId` when it is missing, null or empty, because Wave marks `orderId` as
+     * optional.
+     */
+    handleCallback(request: CallbackRequest): PaymentCallback;
+    private hash;
+}