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

package/dist/cjs/core/validate.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+exports.toAmount = toAmount;
+exports.byteLength = byteLength;
+const amount_js_1 = require("./amount.js");
+const errors_js_1 = require("./errors.js");
+/**
+ * Converts an amount input to an {@link Amount}, or `undefined` when it is missing or not a valid
+ * non-negative amount. Validation reports why.
+ *
+ * @internal
+ */
+function toAmount(value) {
+    if (value instanceof amount_js_1.Amount) {
+        return value;
+    }
+    if ((typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) ||
+        (typeof value === 'bigint' && value >= 0n)) {
+        return amount_js_1.Amount.kyat(value);
+    }
+    return undefined;
+}
+/** UTF-8 byte length, matching the byte limits in the gateway documentation. @internal */
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+/**
+ * Collects one error per field (the first one wins) and throws them together.
+ *
+ * @internal
+ */
+class Validator {
+    errors = {};
+    required(field, value) {
+        if (typeof value !== 'string' || value.trim() === '') {
+            this.fail(field, `The ${field} field is required.`);
+        }
+        return this;
+    }
+    /** Fails when the value is set but not a string. */
+    string(field, value) {
+        if (value !== undefined && value !== null && typeof value !== 'string') {
+            this.fail(field, `The ${field} field must be a string.`);
+        }
+        return this;
+    }
+    length(field, value, min, max) {
+        if (typeof value === 'string' && value !== '') {
+            const size = byteLength(value);
+            if (size < min || size > max) {
+                this.fail(field, `The ${field} field must be between ${min} and ${max} characters.`);
+            }
+        }
+        return this;
+    }
+    max(field, value, max) {
+        if (typeof value === 'string' && byteLength(value) > max) {
+            this.fail(field, `The ${field} field must not be greater than ${max} characters.`);
+        }
+        return this;
+    }
+    pattern(field, value, pattern, description) {
+        if (typeof value === 'string' && value !== '' && !pattern.test(value)) {
+            this.fail(field, `The ${field} field may only contain ${description}.`);
+        }
+        return this;
+    }
+    /** Fails when a set value is not an integer within [min, max]. */
+    between(field, value, min, max) {
+        if (value !== undefined &&
+            value !== null &&
+            (typeof value !== 'number' || !Number.isInteger(value) || value < min || value > max)) {
+            this.fail(field, `The ${field} field must be between ${min} and ${max}.`);
+        }
+        return this;
+    }
+    amount(field, value, rule) {
+        if (value === undefined || value === null) {
+            return this.fail(field, `The ${field} field is required.`);
+        }
+        if (typeof value === 'number' && Number.isFinite(value) && !Number.isInteger(value)) {
+            return this.fail(field, `The ${field} field must be a whole number of kyat or an Amount; use Amount.parse('10.50') for decimal amounts.`);
+        }
+        if (!(value instanceof amount_js_1.Amount) && typeof value !== 'number' && typeof value !== 'bigint') {
+            return this.fail(field, `The ${field} field must be an Amount, e.g. Amount.kyat(1000) or Amount.parse('1000.50').`);
+        }
+        const amount = toAmount(value);
+        if (amount === undefined) {
+            return this.fail(field, `The ${field} field must be a non-negative number such as 1000 or 1000.50.`);
+        }
+        const places = amount.decimalPlaces();
+        if (rule.maxDecimals === 0 && places > 0) {
+            return this.fail(field, `${rule.gateway} does not accept decimal amounts; the ${field} field must be a whole number.`);
+        }
+        if (rule.maxDecimals !== null && rule.maxDecimals > 0 && places > rule.maxDecimals) {
+            return this.fail(field, `${rule.gateway} accepts at most ${rule.maxDecimals} decimal places; the ${field} field has ${places}.`);
+        }
+        if (rule.allowZero !== true && amount.isZero()) {
+            return this.fail(field, `The ${field} field must be greater than 0.`);
+        }
+        if (rule.maxLength !== undefined && amount.toString().length > rule.maxLength) {
+            return this.fail(field, `The ${field} field must not be greater than ${rule.maxLength} characters.`);
+        }
+        return this;
+    }
+    /** Fails when a set value is not an absolute http or https URL. */
+    url(field, value) {
+        if (typeof value !== 'string' || value === '') {
+            return this;
+        }
+        let valid;
+        try {
+            const parsed = new URL(value);
+            valid = (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host !== '';
+        }
+        catch {
+            valid = false;
+        }
+        if (!valid) {
+            this.fail(field, `The ${field} field must be a valid http or https URL.`);
+        }
+        return this;
+    }
+    when(condition, field, message) {
+        if (condition) {
+            this.fail(field, message);
+        }
+        return this;
+    }
+    /** Whether any check failed so far. */
+    failed() {
+        return Object.keys(this.errors).length > 0;
+    }
+    /** Throws an {@link InvalidPaymentDataError} when any check failed. */
+    validate() {
+        if (this.failed()) {
+            throw new errors_js_1.InvalidPaymentDataError(this.errors);
+        }
+    }
+    fail(field, message) {
+        if (!Object.prototype.hasOwnProperty.call(this.errors, field)) {
+            this.errors[field] = message;
+        }
+        return this;
+    }
+}
+exports.Validator = Validator;

package/dist/cjs/core/values.d.ts

@@ -0,0 +1,16 @@
+import { type LosslessObject } from './json.js';
+/**
+ * Returns a scalar as the text a gateway signs: strings as is, numbers exactly as sent, booleans as
+ * `true`/`false`. Objects, arrays, `null` and `undefined` return `undefined`.
+ *
+ * @internal
+ */
+export declare function scalarString(value: unknown): string | undefined;
+/** The value at `key` as a string, or `''` when it is missing or not a scalar. @internal */
+export declare function get(source: Record<string, unknown>, key: string): string;
+/** The value at `key` as a string, or `undefined` when it is missing, `null` or not a scalar. @internal */
+export declare function optional(source: Record<string, unknown>, key: string): string | undefined;
+/** The value at `key` with surrounding whitespace removed. @internal */
+export declare function trimmed(source: Record<string, unknown>, key: string): string;
+/** The value at `key` when it is an object (not an array). @internal */
+export declare function object(source: Record<string, unknown>, key: string): LosslessObject | undefined;

package/dist/cjs/core/values.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalarString = scalarString;
+exports.get = get;
+exports.optional = optional;
+exports.trimmed = trimmed;
+exports.object = object;
+const json_js_1 = require("./json.js");
+/**
+ * Returns a scalar as the text a gateway signs: strings as is, numbers exactly as sent, booleans as
+ * `true`/`false`. Objects, arrays, `null` and `undefined` return `undefined`.
+ *
+ * @internal
+ */
+function scalarString(value) {
+    switch (typeof value) {
+        case 'string':
+            return value;
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'number':
+            return Number.isFinite(value) ? String(value) : undefined;
+        case 'bigint':
+            return value.toString();
+        default:
+            return value instanceof json_js_1.JsonNumber ? value.text : undefined;
+    }
+}
+/** The value at `key` as a string, or `''` when it is missing or not a scalar. @internal */
+function get(source, key) {
+    return scalarString(source[key]) ?? '';
+}
+/** The value at `key` as a string, or `undefined` when it is missing, `null` or not a scalar. @internal */
+function optional(source, key) {
+    return scalarString(source[key]);
+}
+/** The value at `key` with surrounding whitespace removed. @internal */
+function trimmed(source, key) {
+    return get(source, key).trim();
+}
+/** The value at `key` when it is an object (not an array). @internal */
+function object(source, key) {
+    const value = source[key];
+    return (0, json_js_1.isLosslessObject)(value) ? value : undefined;
+}

package/dist/cjs/cyber-source/cyber-source.d.ts

@@ -0,0 +1,95 @@
+import { type AmountInput } from '../core/amount.js';
+import { CallbackRequest, PaymentCallback } from '../core/callback.js';
+import { type EnvSource } from '../core/env.js';
+import { FormPayment } from '../core/results.js';
+/** The settings of {@link CyberSourceConfig}. */
+export interface CyberSourceConfigOptions {
+    /** The Secure Acceptance profile id. */
+    profileId: string;
+    /** The profile's access key. */
+    accessKey: string;
+    /** The profile's secret key, which signs the fields. */
+    secretKey: string;
+    /** Use the test environment (default `true`). */
+    sandbox?: boolean | undefined;
+    /** Overrides the Secure Acceptance base URL. */
+    baseUrl?: string | undefined;
+}
+/**
+ * A CyberSource Secure Acceptance profile. A missing credential throws a `ConfigurationError`.
+ */
+export declare class CyberSourceConfig {
+    static readonly SANDBOX_URL = "https://testsecureacceptance.cybersource.com";
+    static readonly PRODUCTION_URL = "https://secureacceptance.cybersource.com";
+    readonly profileId: string;
+    readonly accessKey: string;
+    readonly secretKey: string;
+    readonly sandbox: boolean;
+    /** The base URL in use. */
+    readonly baseUrl: string;
+    constructor(options: CyberSourceConfigOptions);
+    /**
+     * Reads `CYBER_SOURCE_PROFILE_ID`, `CYBER_SOURCE_ACCESS_KEY`, `CYBER_SOURCE_SECRET_KEY`,
+     * `CYBER_SOURCE_SANDBOX` and `CYBER_SOURCE_BASE_URL`.
+     */
+    static fromEnv(env?: EnvSource): CyberSourceConfig;
+}
+/** What CyberSource does with the card. */
+export type CyberSourceTransactionType = 'sale' | 'authorization' | 'sale,create_payment_token' | 'authorization,create_payment_token';
+/** The CyberSource transaction types. */
+export declare const CyberSourceTransactionType: Readonly<{
+    /** Authorize and capture in one step. */
+    readonly Sale: "sale";
+    /** Authorize only; capture later. */
+    readonly Authorization: "authorization";
+    /** A sale that also saves the card as a payment token. */
+    readonly SaleAndCreateToken: "sale,create_payment_token";
+    /** An authorization that also saves the card as a payment token. */
+    readonly AuthorizationAndCreateToken: "authorization,create_payment_token";
+}>;
+/**
+ * A Secure Acceptance card payment. CyberSource is multi-currency.
+ */
+export interface CyberSourcePaymentData {
+    /** Your order id (`reference_number`), at most 50 characters. Echoed back as `req_reference_number`. */
+    orderId: string;
+    /** The total in `currency`: 0 or more, any decimals, at most 15 characters, e.g. `Amount.parse('10.50')`. */
+    amount: AmountInput;
+    /** The URL CyberSource posts the result to (`override_backoffice_post_url`), at most 255 characters. */
+    callbackUrl: string;
+    /** The receipt page (`override_custom_receipt_page`), at most 255 characters. */
+    returnUrl?: string | undefined;
+    /** The page shown on cancel (`override_custom_cancel_page`), at most 255 characters. */
+    cancelUrl?: string | undefined;
+    /** An ISO 4217 code (default `MMK`). */
+    currency?: string | undefined;
+    /** What to do with the card (default `sale`). */
+    transactionType?: CyberSourceTransactionType | undefined;
+    /** The hosted page language, e.g. `en-us` (the default). */
+    locale?: string | undefined;
+}
+/**
+ * CyberSource Secure Acceptance hosted checkout for card payments: signs the form and verifies the
+ * result posts. Makes no network calls.
+ */
+export declare class CyberSource {
+    /** The configuration in use. */
+    readonly config: CyberSourceConfig;
+    constructor(config: CyberSourceConfig | CyberSourceConfigOptions);
+    /** A gateway configured from the `CYBER_SOURCE_*` environment variables. */
+    static fromEnv(env?: EnvSource): CyberSource;
+    /** Checks the payment against the Secure Acceptance field reference; throws an `InvalidPaymentDataError`. */
+    static validate(data: CyberSourcePaymentData): void;
+    /**
+     * Signs the payment fields. The customer's browser must POST the returned form to CyberSource;
+     * `toHtml()` renders a page that does it.
+     */
+    initiate(data: CyberSourcePaymentData): FormPayment;
+    /**
+     * Verifies CyberSource's result post. The same check works for the browser post to your receipt
+     * page.
+     */
+    handleCallback(request: CallbackRequest): PaymentCallback;
+    /** Signs the fields listed in `signed_field_names`; `undefined` when a listed field is missing. */
+    private sign;
+}

package/dist/cjs/cyber-source/cyber-source.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyberSource = exports.CyberSourceTransactionType = exports.CyberSourceConfig = 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 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");
+/**
+ * A CyberSource Secure Acceptance profile. A missing credential throws a `ConfigurationError`.
+ */
+class CyberSourceConfig {
+    static SANDBOX_URL = 'https://testsecureacceptance.cybersource.com';
+    static PRODUCTION_URL = 'https://secureacceptance.cybersource.com';
+    profileId;
+    accessKey;
+    secretKey;
+    sandbox;
+    /** The base URL in use. */
+    baseUrl;
+    constructor(options) {
+        this.profileId = (0, env_js_1.requireSetting)('cyber_source', 'profile_id', options.profileId);
+        this.accessKey = (0, env_js_1.requireSetting)('cyber_source', 'access_key', options.accessKey);
+        this.secretKey = (0, env_js_1.requireSetting)('cyber_source', 'secret_key', options.secretKey);
+        this.sandbox = options.sandbox ?? true;
+        this.baseUrl = (0, env_js_1.trimUrl)((0, env_js_1.optionalSetting)(options.baseUrl) ??
+            (this.sandbox ? CyberSourceConfig.SANDBOX_URL : CyberSourceConfig.PRODUCTION_URL));
+    }
+    /**
+     * Reads `CYBER_SOURCE_PROFILE_ID`, `CYBER_SOURCE_ACCESS_KEY`, `CYBER_SOURCE_SECRET_KEY`,
+     * `CYBER_SOURCE_SANDBOX` and `CYBER_SOURCE_BASE_URL`.
+     */
+    static fromEnv(env = (0, env_js_1.defaultEnv)()) {
+        return new CyberSourceConfig({
+            profileId: (0, env_js_1.envFirst)(env, 'CYBER_SOURCE_PROFILE_ID'),
+            accessKey: (0, env_js_1.envFirst)(env, 'CYBER_SOURCE_ACCESS_KEY'),
+            secretKey: (0, env_js_1.envFirst)(env, 'CYBER_SOURCE_SECRET_KEY'),
+            sandbox: (0, env_js_1.envSandbox)(env, 'CYBER_SOURCE_SANDBOX'),
+            baseUrl: (0, env_js_1.envFirst)(env, 'CYBER_SOURCE_BASE_URL'),
+        });
+    }
+}
+exports.CyberSourceConfig = CyberSourceConfig;
+/** The CyberSource transaction types. */
+exports.CyberSourceTransactionType = Object.freeze({
+    /** Authorize and capture in one step. */
+    Sale: 'sale',
+    /** Authorize only; capture later. */
+    Authorization: 'authorization',
+    /** A sale that also saves the card as a payment token. */
+    SaleAndCreateToken: 'sale,create_payment_token',
+    /** An authorization that also saves the card as a payment token. */
+    AuthorizationAndCreateToken: 'authorization,create_payment_token',
+});
+const TRANSACTION_TYPES = Object.values(exports.CyberSourceTransactionType);
+const SIGNED_FIELDS = [
+    'access_key',
+    'profile_id',
+    'transaction_uuid',
+    'signed_field_names',
+    'signed_date_time',
+    'locale',
+    'transaction_type',
+    'reference_number',
+    'amount',
+    'currency',
+    'override_custom_receipt_page',
+    'override_backoffice_post_url',
+    'override_custom_cancel_page',
+];
+const STATUSES = {
+    ACCEPT: 'successful',
+    REVIEW: 'pending',
+    DECLINE: 'failed',
+    ERROR: 'failed',
+    CANCEL: 'cancelled',
+};
+/**
+ * CyberSource Secure Acceptance hosted checkout for card payments: signs the form and verifies the
+ * result posts. Makes no network calls.
+ */
+class CyberSource {
+    /** The configuration in use. */
+    config;
+    constructor(config) {
+        this.config = config instanceof CyberSourceConfig ? config : new CyberSourceConfig(config);
+    }
+    /** A gateway configured from the `CYBER_SOURCE_*` environment variables. */
+    static fromEnv(env = (0, env_js_1.defaultEnv)()) {
+        return new CyberSource(CyberSourceConfig.fromEnv(env));
+    }
+    /** Checks the payment against the Secure Acceptance field reference; throws an `InvalidPaymentDataError`. */
+    static validate(data) {
+        new validate_js_1.Validator()
+            .required('orderId', data.orderId)
+            .max('orderId', data.orderId, 50)
+            .amount('amount', data.amount, {
+            gateway: 'CyberSource',
+            maxDecimals: null,
+            maxLength: 15,
+            allowZero: true,
+        })
+            .required('callbackUrl', data.callbackUrl)
+            .url('callbackUrl', data.callbackUrl)
+            .max('callbackUrl', data.callbackUrl, 255)
+            .string('returnUrl', data.returnUrl)
+            .url('returnUrl', data.returnUrl)
+            .max('returnUrl', data.returnUrl, 255)
+            .string('cancelUrl', data.cancelUrl)
+            .url('cancelUrl', data.cancelUrl)
+            .max('cancelUrl', data.cancelUrl, 255)
+            .pattern('currency', String(data.currency || 'MMK'), /^[A-Z]{3}$/, 'a three letter ISO 4217 code')
+            .pattern('locale', String(data.locale || 'en-us'), /^[a-z]{2}-[a-z]{2}$/, 'a locale code such as en-us')
+            .when(!TRANSACTION_TYPES.includes(String(data.transactionType || 'sale')), 'transactionType', 'The transactionType field is not a supported transaction type.')
+            .validate();
+    }
+    /**
+     * Signs the payment fields. The customer's browser must POST the returned form to CyberSource;
+     * `toHtml()` renders a page that does it.
+     */
+    initiate(data) {
+        CyberSource.validate(data);
+        const values = {
+            access_key: this.config.accessKey,
+            profile_id: this.config.profileId,
+            transaction_uuid: (0, crypto_js_1.randomHex)(),
+            signed_field_names: SIGNED_FIELDS.join(','),
+            signed_date_time: new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'),
+            locale: data.locale || 'en-us',
+            transaction_type: data.transactionType || 'sale',
+            reference_number: data.orderId,
+            amount: String((0, validate_js_1.toAmount)(data.amount)),
+            currency: data.currency || 'MMK',
+            override_custom_receipt_page: data.returnUrl ?? '',
+            override_backoffice_post_url: data.callbackUrl,
+            override_custom_cancel_page: data.cancelUrl ?? '',
+        };
+        const fields = SIGNED_FIELDS.map((name) => ({ name, value: values[name] }));
+        fields.push({ name: 'signature', value: this.sign(values) });
+        return new results_js_1.FormPayment({
+            orderId: data.orderId,
+            action: `${this.config.baseUrl}/pay`,
+            fields,
+        });
+    }
+    /**
+     * Verifies CyberSource's result post. The same check works for the browser post to your receipt
+     * page.
+     */
+    handleCallback(request) {
+        const payload = (0, callback_js_1.losslessInput)(request);
+        const expected = this.sign(payload);
+        if (expected === undefined || !(0, crypto_js_1.safeEqual)(expected, (0, values_js_1.get)(payload, 'signature'))) {
+            throw new errors_js_1.SignatureVerificationError('CyberSource callback signature verification failed.', (0, json_js_1.toPlainObject)(payload));
+        }
+        const decision = (0, values_js_1.trimmed)(payload, 'decision').toUpperCase();
+        return new callback_js_1.PaymentCallback({
+            orderId: (0, values_js_1.get)(payload, 'req_reference_number'),
+            status: (0, status_js_1.resolveStatus)(STATUSES, decision),
+            gatewayStatus: decision,
+            gatewayReference: (0, values_js_1.optional)(payload, 'transaction_id'),
+            amount: (0, values_js_1.get)(payload, 'auth_amount') || (0, values_js_1.optional)(payload, 'req_amount'),
+            raw: (0, json_js_1.toPlainObject)(payload),
+        });
+    }
+    /** Signs the fields listed in `signed_field_names`; `undefined` when a listed field is missing. */
+    sign(fields) {
+        const pairs = [];
+        for (const name of (0, values_js_1.get)(fields, 'signed_field_names').split(',')) {
+            if (name === '') {
+                continue;
+            }
+            const value = (0, values_js_1.scalarString)(fields[name]);
+            if (value === undefined) {
+                return undefined;
+            }
+            pairs.push(`${name}=${value}`);
+        }
+        return pairs.length === 0
+            ? undefined
+            : (0, crypto_js_1.hmacSha256Base64)(this.config.secretKey, pairs.join(','));
+    }
+}
+exports.CyberSource = CyberSource;

package/dist/cjs/cyber-source/index.d.ts

@@ -0,0 +1 @@
+export { CyberSource, CyberSourceConfig, CyberSourceTransactionType, type CyberSourceConfigOptions, type CyberSourcePaymentData, } from './cyber-source.js';

package/dist/cjs/cyber-source/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyberSourceTransactionType = exports.CyberSourceConfig = exports.CyberSource = void 0;
+var cyber_source_js_1 = require("./cyber-source.js");
+Object.defineProperty(exports, "CyberSource", { enumerable: true, get: function () { return cyber_source_js_1.CyberSource; } });
+Object.defineProperty(exports, "CyberSourceConfig", { enumerable: true, get: function () { return cyber_source_js_1.CyberSourceConfig; } });
+Object.defineProperty(exports, "CyberSourceTransactionType", { enumerable: true, get: function () { return cyber_source_js_1.CyberSourceTransactionType; } });

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core/index.js';
+export * from './aya-pay/index.js';
+export * from './cyber-source/index.js';
+export * from './kbz-pay/index.js';
+export * from './wave-money/index.js';
+export * from './yoma-mmqr/index.js';
+export { MyanmarPayments, type MyanmarPaymentsConfig, type MyanmarPaymentsOptions, } from './myanmar-payments.js';

package/dist/cjs/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyanmarPayments = void 0;
+__exportStar(require("./core/index.js"), exports);
+__exportStar(require("./aya-pay/index.js"), exports);
+__exportStar(require("./cyber-source/index.js"), exports);
+__exportStar(require("./kbz-pay/index.js"), exports);
+__exportStar(require("./wave-money/index.js"), exports);
+__exportStar(require("./yoma-mmqr/index.js"), exports);
+var myanmar_payments_js_1 = require("./myanmar-payments.js");
+Object.defineProperty(exports, "MyanmarPayments", { enumerable: true, get: function () { return myanmar_payments_js_1.MyanmarPayments; } });

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

@@ -0,0 +1,2 @@
+export { KbzPay, KbzPayConfig, type KbzPayConfigOptions, type KbzPayPaymentData, } from './kbz-pay.js';
+export { KbzPaySigner } from './signer.js';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KbzPaySigner = exports.KbzPayConfig = exports.KbzPay = void 0;
+var kbz_pay_js_1 = require("./kbz-pay.js");
+Object.defineProperty(exports, "KbzPay", { enumerable: true, get: function () { return kbz_pay_js_1.KbzPay; } });
+Object.defineProperty(exports, "KbzPayConfig", { enumerable: true, get: function () { return kbz_pay_js_1.KbzPayConfig; } });
+var signer_js_1 = require("./signer.js");
+Object.defineProperty(exports, "KbzPaySigner", { enumerable: true, get: function () { return signer_js_1.KbzPaySigner; } });

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

@@ -0,0 +1,102 @@
+import { type AmountInput } from '../core/amount.js';
+import { CallbackRequest, PaymentCallback, PaymentStatusResult } from '../core/callback.js';
+import { type EnvSource } from '../core/env.js';
+import { type GatewayOptions, type RequestOptions } from '../core/http.js';
+import { AppPayment, QrPayment, RedirectPayment } from '../core/results.js';
+import { KbzPaySigner } from './signer.js';
+/** The settings of {@link KbzPayConfig}. */
+export interface KbzPayConfigOptions {
+    /** The `appid` KBZ issued for your merchant app. */
+    appId: string;
+    /** The secret key used to sign requests. */
+    appKey: string;
+    /** The `merch_code` KBZ issued. */
+    merchantCode: string;
+    /** Use the UAT endpoints (default `true`). UAT and production issue separate credentials. */
+    sandbox?: boolean | undefined;
+    /** Overrides the API base URL, e.g. to go through a proxy. */
+    apiUrl?: string | undefined;
+    /** Overrides the PWA checkout URL. A trailing `#` or `#/` is normalized to `#/`. */
+    pwaUrl?: string | undefined;
+}
+/**
+ * KBZ Pay credentials and endpoints. A missing credential throws a `ConfigurationError`.
+ */
+export declare class KbzPayConfig {
+    static readonly SANDBOX_API_URL = "http://api-uat.kbzpay.com/payment/gateway/uat";
+    static readonly PRODUCTION_API_URL = "https://api.kbzpay.com/payment/gateway";
+    static readonly SANDBOX_PWA_URL = "https://static.kbzpay.com/pgw/uat/pwa/#/";
+    static readonly PRODUCTION_PWA_URL = "https://wap.kbzpay.com/pgw/pwa/#/";
+    readonly appId: string;
+    readonly appKey: string;
+    readonly merchantCode: string;
+    readonly sandbox: boolean;
+    /** The API base URL in use. */
+    readonly apiUrl: string;
+    /** The PWA checkout URL in use, always ending in `/`. */
+    readonly pwaUrl: string;
+    constructor(options: KbzPayConfigOptions);
+    /**
+     * 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?: EnvSource): KbzPayConfig;
+}
+/**
+ * A KBZ Pay order, used for the PWA, QR and in-app flows alike. KBZ Pay only accepts MMK.
+ */
+export interface KbzPayPaymentData {
+    /** Your unique order id (`merch_order_id`): letters, digits and `_` only, at most 40. */
+    orderId: string;
+    /** Kyat, greater than 0 with at most 2 decimal places, e.g. `Amount.kyat(1000)` or `Amount.parse('1000.50')`. */
+    amount: AmountInput;
+    /** The public URL KBZ posts the result to (`notify_url`): at most 512 characters, no query string. */
+    callbackUrl: string;
+    /** The product name shown to the customer. */
+    title?: string | undefined;
+    /** How long the order stays payable, 1 to 120 minutes. KBZ defaults to 120. */
+    timeoutMinutes?: number | undefined;
+    /** Free text KBZ sends back unchanged in the callback, at most 512 characters once URL-encoded. */
+    callbackInfo?: string | undefined;
+}
+/**
+ * KBZ Pay: PWA (redirect), QR and in-app payments, order status queries and payment
+ * notifications.
+ */
+export declare class KbzPay {
+    /** The configuration in use. */
+    readonly config: KbzPayConfig;
+    /** KBZ Pay's request signer, for custom calls. */
+    readonly signer: KbzPaySigner;
+    private readonly transport;
+    constructor(config: KbzPayConfig | KbzPayConfigOptions, options?: GatewayOptions);
+    /** A gateway configured from the `KBZ_PAY_*` environment variables. */
+    static fromEnv(env?: EnvSource, options?: GatewayOptions): KbzPay;
+    /** Checks the order against KBZ's documented limits; throws an `InvalidPaymentDataError`. */
+    static validate(data: KbzPayPaymentData): void;
+    /**
+     * 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.
+     */
+    pwa(data: KbzPayPaymentData, options?: RequestOptions): Promise<RedirectPayment>;
+    /** Creates an order and returns a QR payload for the customer to scan with the KBZ Pay app. */
+    qr(data: KbzPayPaymentData, options?: RequestOptions): Promise<QrPayment>;
+    /**
+     * 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()`.
+     */
+    app(data: KbzPayPaymentData, options?: RequestOptions): Promise<AppPayment>;
+    /** Asks KBZ Pay for the current state of an order (`queryorder`). */
+    status(orderId: string, options?: RequestOptions): Promise<PaymentStatusResult>;
+    /**
+     * Verifies KBZ Pay's payment notification. Reply with the callback's `acknowledgement` (plain
+     * `success`) or KBZ retries.
+     */
+    handleCallback(request: CallbackRequest): PaymentCallback;
+    private precreate;
+    /** Sends a signed request and returns the `Response` object, throwing when KBZ reports an error. */
+    private call;
+    private orderInfoFields;
+}