@dpayglobal/dpay-node-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1709 @@
+import { isScalar, phpStrval, phpJsonEncode, phpRound, ApiResponse, isNumeric, phpInt, isPhpBool, isPhpInt } from './chunk-SPQCX4N4.js';
+export { ApiResponse } from './chunk-SPQCX4N4.js';
+import { timingSafeEqual, createHash, createPublicKey, publicEncrypt, constants } from 'crypto';
+import { inspect } from 'util';
+
+// src/errors.ts
+var DPayError = class extends Error {
+  /** Stable discriminator, usable in `switch` when `instanceof` is unreliable. */
+  type = "value_error";
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    Error.captureStackTrace?.(this, new.target);
+  }
+};
+var DPayValueError = class extends DPayError {
+  type = "value_error";
+};
+var TransportError = class extends DPayError {
+  type = "transport_error";
+};
+var SignatureVerificationError = class extends DPayError {
+  type = "signature_verification_error";
+};
+var CardEncryptionError = class extends DPayError {
+  type = "card_encryption_error";
+};
+var ApiError = class extends DPayError {
+  type = "api_error";
+  /** HTTP status of the response, or 200 for rejections carried in a success body. */
+  httpStatus;
+  /** Business error code from the API, when present. */
+  errorCode;
+  /** Per-field validation messages, normalized across the 400 and 422 formats. */
+  fieldErrors;
+  /** Unparsed response body. */
+  rawBody;
+  constructor(message, httpStatus, errorCode = null, fieldErrors = {}, rawBody = "") {
+    super(message);
+    this.httpStatus = httpStatus;
+    this.errorCode = errorCode;
+    this.fieldErrors = fieldErrors;
+    this.rawBody = rawBody;
+  }
+};
+var AuthenticationError = class extends ApiError {
+  type = "authentication_error";
+};
+var InvalidRequestError = class extends ApiError {
+  type = "invalid_request_error";
+};
+var AccessDeniedError = class extends ApiError {
+  type = "access_denied_error";
+};
+var NotFoundError = class extends ApiError {
+  type = "not_found_error";
+};
+var ApiServerError = class extends ApiError {
+  type = "api_server_error";
+};
+var RateLimitError = class extends ApiError {
+  type = "rate_limit_error";
+  /** Seconds from the `Retry-After` header. */
+  retryAfter;
+  /** Value of `X-RateLimit-Limit`. */
+  limit;
+  /** Value of `X-RateLimit-Remaining`. */
+  remaining;
+  constructor(message, httpStatus, retryAfter = null, limit = null, remaining = null, rawBody = "") {
+    super(message, httpStatus, null, {}, rawBody);
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.remaining = remaining;
+  }
+};
+var PaymentRejectedError = class _PaymentRejectedError extends ApiError {
+  type = "payment_rejected_error";
+  /** Transaction identifier returned alongside the rejection, when present. */
+  transactionId;
+  constructor(message, httpStatus, errorCode = null, fieldErrors = {}, rawBody = "", transactionId = null) {
+    super(message, httpStatus, errorCode, fieldErrors, rawBody);
+    this.transactionId = transactionId;
+  }
+  static fromApi(data) {
+    const message = typeof data.msg === "string" ? data.msg : "Payment rejected";
+    const additional = isRecord(data.additionalInfo) ? data.additionalInfo : {};
+    const errorCode = typeof additional.error === "string" ? additional.error : null;
+    const transactionId = isScalar(data.transactionId) ? phpStrval(data.transactionId) : null;
+    return new _PaymentRejectedError(message, 200, errorCode, {}, phpJsonEncode(data), transactionId);
+  }
+};
+var CardPaymentError = class _CardPaymentError extends ApiError {
+  type = "card_payment_error";
+  static fromApi(data) {
+    const message = typeof data.message === "string" ? data.message : "Card payment failed";
+    return new _CardPaymentError(message, 200, message, {}, phpJsonEncode(data));
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/base-urls.ts
+var API_PAYMENTS = "apiPayments";
+var PANEL = "panel";
+var DEFAULT_BASE_URLS = {
+  apiPayments: "https://api-payments.dpay.pl",
+  panel: "https://panel.dpay.pl",
+  gateway: "https://secure.dpay.pl"
+};
+var BaseUrls = class {
+  urls;
+  constructor(overrides = {}) {
+    for (const key of Object.keys(overrides)) {
+      if (!Object.hasOwn(DEFAULT_BASE_URLS, key)) throw new DPayValueError(`Unknown base URL key "${key}"`);
+    }
+    this.urls = { ...DEFAULT_BASE_URLS };
+    for (const [key, url] of Object.entries(overrides)) {
+      this.urls[key] = url.replace(/\/+$/, "");
+    }
+  }
+  resolve(host) {
+    const url = this.urls[host];
+    if (!Object.hasOwn(this.urls, host) || url === void 0)
+      throw new DPayValueError(`Unknown API host "${host}"`);
+    return url;
+  }
+};
+
+// src/internal/operation.ts
+function decodeJsonOrFail(response) {
+  const data = response.decodeJson();
+  if (data === null) {
+    throw new ApiServerError("Invalid JSON in API response", response.status, null, {}, response.body);
+  }
+  return data;
+}
+function decodeRecordOrFail(response) {
+  const data = decodeJsonOrFail(response);
+  return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+}
+
+// src/currency.ts
+var PATTERN = /^[A-Z]{3}$/;
+var Currency = { PLN: "PLN", EUR: "EUR", CZK: "CZK" };
+function isValidCurrency(code) {
+  return PATTERN.test(code);
+}
+function assertCurrency(code) {
+  if (!isValidCurrency(code)) throw new DPayValueError(`Invalid currency code "${code}"`);
+}
+
+// src/money.ts
+var DECIMAL = /^(-?)(\d+)(?:\.(\d{1,2}))?$/;
+var Money = class _Money {
+  /** Amount in minor units, for example 1050 for 10.50 PLN. */
+  minor;
+  /** Three-letter currency code. */
+  currency;
+  constructor(minor, currency) {
+    if (!Number.isSafeInteger(minor)) {
+      throw new DPayValueError("Money amount must be a safe integer number of minor units");
+    }
+    this.minor = minor;
+    this.currency = currency;
+    Object.freeze(this);
+  }
+  /** Amount in Polish grosz, for example `Money.pln(1050)` is 10.50 PLN. */
+  static pln(minor) {
+    return new _Money(minor, Currency.PLN);
+  }
+  /** Amount in minor units of an arbitrary currency. */
+  static of(minor, currency) {
+    assertCurrency(currency);
+    return new _Money(minor, currency);
+  }
+  /** Parses a decimal string with at most two fraction digits. */
+  static fromDecimal(decimal, currency) {
+    assertCurrency(currency);
+    const parsed = parseDecimal(decimal);
+    if (parsed === null) throw new DPayValueError(`Invalid money amount "${decimal}"`);
+    return new _Money(parsed, currency);
+  }
+  /** Parses whatever shape the API used for this field. Throws on anything unparsable. */
+  static fromApiNumber(value, currency) {
+    const money = _Money.tryFromApiNumber(value, currency);
+    if (money === null) throw new DPayValueError("Money value must be a number or a decimal string");
+    return money;
+  }
+  /** Same as `fromApiNumber`, but returns null instead of throwing. */
+  static tryFromApiNumber(value, currency) {
+    if (!isValidCurrency(currency)) return null;
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) return null;
+      const minor = phpRound(value * 100);
+      return Number.isSafeInteger(minor) ? new _Money(minor, currency) : null;
+    }
+    if (typeof value === "string") {
+      const parsed = parseDecimal(value);
+      if (parsed === null || !Number.isSafeInteger(parsed)) return null;
+      return new _Money(parsed, currency);
+    }
+    return null;
+  }
+  /** Renders the amount as a decimal string with exactly two fraction digits. */
+  toDecimal() {
+    const absolute = Math.abs(this.minor);
+    const sign = this.minor < 0 ? "-" : "";
+    const fraction = String(absolute % 100).padStart(2, "0");
+    return `${sign}${Math.floor(absolute / 100)}.${fraction}`;
+  }
+  get isNegative() {
+    return this.minor < 0;
+  }
+  equals(other) {
+    return this.minor === other.minor && this.currency === other.currency;
+  }
+  toString() {
+    return `${this.toDecimal()} ${this.currency}`;
+  }
+  toJSON() {
+    return { minor: this.minor, currency: this.currency };
+  }
+};
+function parseDecimal(decimal) {
+  const match = DECIMAL.exec(decimal);
+  if (match === null) return null;
+  const fraction = (match[3] ?? "").padEnd(2, "0");
+  const minor = Number(match[2]) * 100 + Number(fraction);
+  return match[1] === "-" ? -minor : minor;
+}
+
+// src/payment/enums.ts
+var TransactionType = {
+  TRANSFERS: "transfers",
+  DCB_GATEWAY: "dcb_gateway",
+  CARD_AUTH: "card_auth",
+  MB_WAY_DIRECT: "mb_way_direct",
+  BIZUM_DIRECT: "bizum_direct",
+  BLIK_RECURRING: "blik_recurring",
+  CARD_RECURRING: "card_recurring"
+};
+function assertTransactionType(value) {
+  if (!Object.values(TransactionType).includes(value)) {
+    throw new DPayValueError(`Invalid transaction type "${value}"`);
+  }
+}
+var TransactionStatus = {
+  PAID: "paid",
+  CREATED: "created",
+  PROCESSING: "processing",
+  EXPIRED: "expired",
+  CAPTURED: "captured"
+};
+var PayoutFeeMode = { NET: "net", GROSS: "gross" };
+function assertPayoutFeeMode(value) {
+  if (!Object.values(PayoutFeeMode).includes(value)) {
+    throw new DPayValueError(`Invalid payout fee mode "${value}"`);
+  }
+}
+
+// src/payment/models.ts
+var HTTP_URL = /^https?:\/\//;
+function parseRegisteredPayment(data) {
+  const message = scalarString(data, "msg");
+  const additional = record(data.additionalInfo);
+  return Object.freeze({
+    transactionId: scalarString(data, "transactionId"),
+    message,
+    ipksef: strictString(data, "ipksef"),
+    redirectUrl: HTTP_URL.test(message) ? message : null,
+    isPaid: message === "Transaction paid",
+    isInternalProcessing: message === "Internal processing",
+    cardRecurringAlias: additional === null ? null : strictString(additional, "card_recurring_alias"),
+    raw: data
+  });
+}
+function parseTransaction(data) {
+  const inner = record(data.transaction) ?? {};
+  const status = scalarString(inner, "status");
+  const refunds = Array.isArray(data.refunds) ? data.refunds : [];
+  return Object.freeze({
+    id: scalarString(inner, "id"),
+    value: moneyOrZero(inner, "value"),
+    status,
+    paymentMethod: scalarStringOrNull(inner, "payment_method"),
+    creationDate: scalarStringOrNull(inner, "creation_date"),
+    paymentDate: strictString(inner, "payment_date"),
+    isPaid: status === TransactionStatus.PAID || status === TransactionStatus.CAPTURED,
+    isSettled: Boolean(inner.settled),
+    isRefunded: Boolean(inner.refunded),
+    refundedAmount: moneyOrZero(inner, "refunded_amount"),
+    availableRefundAmount: moneyOrZero(inner, "available_refund_amount"),
+    isFullyRefunded: Boolean(inner.fully_refunded),
+    isDirect: Boolean(inner.direct),
+    gatewayId: strictString(inner, "gateway_id"),
+    payer: record(data.payer) ?? {},
+    refunds: Object.freeze(
+      refunds.filter((item) => record(item) !== null).map(parseTransactionRefund)
+    ),
+    raw: data
+  });
+}
+function parseTransactionRefund(data) {
+  const status = scalarStringOrNull(data, "status");
+  return Object.freeze({
+    paymentId: scalarString(data, "payment_id"),
+    value: moneyOrZero(data, "value"),
+    status: status ?? TransactionStatus.PAID,
+    creationDate: scalarStringOrNull(data, "creation_date"),
+    paymentDate: scalarStringOrNull(data, "payment_date"),
+    raw: data
+  });
+}
+function scalarString(data, key) {
+  const value = data[key];
+  return isScalar(value) ? phpStrval(value) : "";
+}
+function scalarStringOrNull(data, key) {
+  const value = data[key];
+  return isScalar(value) ? phpStrval(value) : null;
+}
+function strictString(data, key) {
+  const value = data[key];
+  return typeof value === "string" ? value : null;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function moneyOrZero(data, key) {
+  return Money.tryFromApiNumber(data[key] ?? 0, Currency.PLN) ?? Money.pln(0);
+}
+
+// src/bank/models.ts
+function parseBank(data) {
+  return Object.freeze({
+    id: scalarString(data, "id"),
+    name: scalarString(data, "name"),
+    image: strictString(data, "image"),
+    onFrom: isScalar(data.on_from) ? phpInt(data.on_from) : 0,
+    onTo: isScalar(data.on_to) ? phpInt(data.on_to) : 0,
+    iterator: isScalar(data.iterator) ? phpInt(data.iterator) : null,
+    isTest: isScalar(data.test) ? phpBool(data.test) : false,
+    type: strictString(data, "type"),
+    raw: data
+  });
+}
+function phpBool(value) {
+  if (typeof value === "string") return value !== "" && value !== "0";
+  return Boolean(value);
+}
+
+// src/bank/ops.ts
+function allBanksOperation() {
+  return { method: "GET", host: PANEL, path: "/api/v1/pbl/banks", parse: parseBanks };
+}
+function forServiceOperation(service, checksum, timestamp) {
+  const body = {
+    service,
+    timestamp: timestamp ?? Math.floor(Date.now() / 1e3)
+  };
+  body.checksum = checksum.orderedBody(Object.values(body));
+  return { method: "POST", host: PANEL, path: "/api/v1/pbl/banks", body, parse: parseBanks };
+}
+function parseBanks(response) {
+  const data = decodeJsonOrFail(response);
+  const items = Array.isArray(data) ? data : Object.values(data);
+  return items.filter(
+    (item) => typeof item === "object" && item !== null && !Array.isArray(item)
+  ).map(parseBank);
+}
+
+// src/bank/service.ts
+var BankService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /** Every bank dpay supports. */
+  async all(options) {
+    return this.api.execute(allBanksOperation(), options);
+  }
+  /** Banks enabled for this payment point. Defaults `timestamp` to the current clock. */
+  async forService(params, options) {
+    return this.api.execute(
+      forServiceOperation(this.api.service, this.api.checksum, params?.timestamp),
+      options
+    );
+  }
+};
+
+// src/blik/enums.ts
+var BlikAliasType = { UID: "UID", PAYID: "PAYID" };
+function assertBlikAliasType(value) {
+  if (!Object.values(BlikAliasType).includes(value)) {
+    throw new DPayValueError(`Invalid BLIK alias type "${value}"`);
+  }
+}
+
+// src/blik/models.ts
+function parseBlikAlias(data) {
+  const status = strictString(data, "status");
+  const apps = Array.isArray(data.apps) ? data.apps : [];
+  return Object.freeze({
+    aliasValue: scalarStringOr(data, "alias_value", ""),
+    aliasType: scalarStringOr(data, "alias_type", BlikAliasType.UID),
+    status,
+    expirationDate: strictString(data, "expiration_date"),
+    apps: Object.freeze(
+      apps.filter((app) => record(app) !== null).map((app) => Object.freeze({ key: strictString(app, "key"), label: strictString(app, "label") }))
+    ),
+    isActive: status === "ACTIVE",
+    raw: data
+  });
+}
+function parseBlikRecurringStatus(data) {
+  const status = strictString(data, "status");
+  const registration = record(data.registration);
+  return Object.freeze({
+    aliasValue: scalarStringOr(data, "alias_value", ""),
+    aliasType: scalarStringOr(data, "alias_type", BlikAliasType.PAYID),
+    status,
+    expirationDate: strictString(data, "expiration_date"),
+    registration: registration === null ? null : parseRegistrationInfo(registration),
+    isActive: status === "ACTIVE",
+    raw: data
+  });
+}
+function parseRegistrationInfo(data) {
+  return Object.freeze({
+    model: strictString(data, "model"),
+    frequency: strictString(data, "frequency"),
+    limitAmt: isPhpInt(data.limit_amt) ? data.limit_amt : null,
+    totLimitAmt: isPhpInt(data.tot_limit_amt) ? data.tot_limit_amt : null,
+    isLimitAmtFixed: isPhpBool(data.is_limit_amt_fixed) ? data.is_limit_amt_fixed : null,
+    initDate: strictString(data, "init_date"),
+    label: strictString(data, "label"),
+    registeredAt: strictString(data, "registered_at"),
+    raw: data
+  });
+}
+function scalarStringOr(data, key, fallback) {
+  const value = data[key];
+  return isScalar(value) ? phpStrval(value) : fallback;
+}
+
+// src/blik/ops.ts
+function aliasBody(service, params) {
+  const aliasType = params.aliasType ?? "UID";
+  assertBlikAliasType(aliasType);
+  return { service, alias_value: params.aliasValue, alias_type: aliasType };
+}
+function envelope(response) {
+  return record(decodeRecordOrFail(response).data) ?? {};
+}
+function aliasOperation(service, checksum, params) {
+  const body = aliasBody(service, params);
+  body.checksum = checksum.secretSecond(service, [params.aliasValue]);
+  return {
+    method: "POST",
+    host: API_PAYMENTS,
+    path: "/api/v1_0/payments/blik/aliases",
+    body,
+    parse: (response) => parseBlikAlias(envelope(response))
+  };
+}
+function unregisterAliasOperation(service, checksum, params) {
+  const body = aliasBody(service, params);
+  if (params.reason !== void 0) body.reason = params.reason;
+  body.checksum = checksum.secretSecond(service, [params.aliasValue]);
+  return {
+    method: "POST",
+    host: API_PAYMENTS,
+    path: "/api/v1_0/payments/blik/aliases/unregister",
+    body,
+    parse: (response) => {
+      decodeRecordOrFail(response);
+    }
+  };
+}
+function recurringStatusOperation(service, checksum, params) {
+  const body = { service, alias_value: params.aliasValue };
+  body.checksum = checksum.secretSecond(service, [params.aliasValue]);
+  return {
+    method: "POST",
+    host: API_PAYMENTS,
+    path: "/api/v1_0/payments/blik/recurring/status",
+    body,
+    parse: (response) => parseBlikRecurringStatus(envelope(response))
+  };
+}
+
+// src/blik/service.ts
+var BlikService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /** Registers a BLIK alias so the payer can pay without a code next time. */
+  async alias(params, options) {
+    return this.api.execute(aliasOperation(this.api.service, this.api.checksum, params), options);
+  }
+  /** Removes a BLIK alias. */
+  async unregisterAlias(params, options) {
+    return this.api.execute(unregisterAliasOperation(this.api.service, this.api.checksum, params), options);
+  }
+  /** Reads the state of a recurring BLIK mandate. */
+  async recurringStatus(params, options) {
+    return this.api.execute(recurringStatusOperation(this.api.service, this.api.checksum, params), options);
+  }
+};
+
+// src/card/enums.ts
+var RedirectType = {
+  SUCCESS: "SUCCESS",
+  FORM: "FORM",
+  URL: "URL",
+  DCC_OFFER: "DCC_OFFER"
+};
+var DccDecision = { ACCEPT: "accept", REJECT: "reject" };
+function assertDccDecision(value) {
+  if (!Object.values(DccDecision).includes(value)) {
+    throw new DPayValueError(`Invalid DCC decision "${value}"`);
+  }
+}
+var CardRecurringOperation = {
+  ADD_CARD: "add_card",
+  COF_INITIAL: "cof_initial",
+  CHARGE: "charge"
+};
+function assertCardRecurringOperation(value) {
+  if (!Object.values(CardRecurringOperation).includes(value)) {
+    throw new DPayValueError(`Invalid card recurring operation "${value}"`);
+  }
+}
+var CardRecurringFrequency = {
+  DAILY: "DAILY",
+  WEEKLY: "WEEKLY",
+  BIWEEKLY: "BIWEEKLY",
+  MONTHLY: "MONTHLY",
+  QUARTERLY: "QUARTERLY",
+  SEMIANNUAL: "SEMIANNUAL",
+  ANNUAL: "ANNUAL"
+};
+function assertCardRecurringFrequency(value) {
+  if (!Object.values(CardRecurringFrequency).includes(value)) {
+    throw new DPayValueError(`Invalid card recurring frequency "${value}"`);
+  }
+}
+
+// src/card/models.ts
+function parseCardPaymentResult(data) {
+  const message = record(data.message) ?? {};
+  const redirectType = strictString(message, "redirectType");
+  const redirectTextRaw = strictString(message, "redirectText");
+  const redirectText = redirectTextRaw === null || redirectTextRaw === "" ? null : redirectTextRaw;
+  const offer = record(message.dccOffer);
+  const requiresThreeDsForm = redirectType === RedirectType.FORM;
+  const requiresRedirect = redirectType === RedirectType.URL;
+  return Object.freeze({
+    redirectType,
+    redirectText,
+    isSuccess: redirectType === RedirectType.SUCCESS,
+    requiresThreeDsForm,
+    requiresRedirect,
+    hasDccOffer: redirectType === RedirectType.DCC_OFFER,
+    threeDsFormHtml: requiresThreeDsForm && redirectText !== null ? decodeBase64(redirectText) : null,
+    redirectUrl: requiresRedirect && redirectText !== null ? decodeBase64(redirectText) : null,
+    dccOffer: offer === null ? null : parseDccOffer(offer),
+    raw: data
+  });
+}
+function parseDccOffer(data) {
+  const markup = Array.isArray(data.markup) ? data.markup : [];
+  return Object.freeze({
+    currencyConversionId: scalarString(data, "currencyConversionId"),
+    originalAmount: amount(data, "originalAmount", "originalCurrency"),
+    convertedAmount: amount(data, "convertedAmount", "convertedCurrency"),
+    exchangeRate: floatOrZero(data, "exchangeRate"),
+    validUntil: scalarString(data, "validUntil"),
+    declarationText: scalarString(data, "declarationText"),
+    isEuropeanEconomicArea: Boolean(data.europeanEconomicArea),
+    markup: Object.freeze(
+      markup.filter((item) => record(item) !== null).map(
+        (item) => Object.freeze({
+          rate: floatOrZero(item, "rate"),
+          additionalInfo: strictString(item, "additionalInfo")
+        })
+      )
+    ),
+    raw: data
+  });
+}
+function amount(data, amountKey, currencyKey) {
+  const currency = data[currencyKey];
+  return Money.tryFromApiNumber(data[amountKey] ?? 0, typeof currency === "string" ? currency : Currency.PLN) ?? Money.pln(0);
+}
+function floatOrZero(data, key) {
+  const value = data[key] ?? 0;
+  return isNumeric(value) ? Number(value) : 0;
+}
+function decodeBase64(text) {
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(text) || text.length % 4 !== 0) return null;
+  return Buffer.from(text, "base64").toString("utf8");
+}
+
+// src/internal/validation.ts
+var EMAIL = /^[^@\s]+@[^@\s.]+(\.[^@\s.]+)+$/;
+var DATE = /^\d{4}-\d{2}-\d{2}$/;
+function isValidUrl(url) {
+  if (url === "") return false;
+  for (const char of url) {
+    const code = char.charCodeAt(0);
+    if (code <= 32 || code === 127) return false;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  return parsed.protocol !== "" && parsed.host !== "";
+}
+function isValidEmail(email) {
+  return EMAIL.test(email);
+}
+function isValidDate(date) {
+  return DATE.test(date);
+}
+function assertDate(date) {
+  if (!isValidDate(date)) throw new DPayValueError(`Date "${date}" must be in YYYY-MM-DD format`);
+  return date;
+}
+
+// src/payment/params.ts
+function serializeDeviceInfo(info) {
+  if (info.deviceId === "" || info.deviceId.length > 64) {
+    throw new DPayValueError("Device ID must be 1-64 characters");
+  }
+  if (info.applicationName === "" || info.applicationName.length > 64) {
+    throw new DPayValueError("Application name must be 1-64 characters");
+  }
+  const data = {
+    browserAcceptHeader: info.browserAcceptHeader,
+    browserLanguage: info.browserLanguage,
+    browserColorDepth: info.browserColorDepth,
+    browserScreenHeight: info.browserScreenHeight,
+    browserScreenWidth: info.browserScreenWidth,
+    browserTZ: info.browserTz,
+    browserUserAgent: info.browserUserAgent,
+    systemFamily: info.systemFamily,
+    geoLocalization: info.geoLocalization,
+    deviceID: info.deviceId,
+    applicationName: info.applicationName
+  };
+  if (info.browserJavaEnabled !== void 0) {
+    data.browserJavaEnabled = info.browserJavaEnabled ? "true" : "false";
+  }
+  return data;
+}
+function serializeInvoice(invoice) {
+  const data = {};
+  if (invoice.payerNip !== void 0) data.payer_nip = invoice.payerNip;
+  if (invoice.payerName !== void 0) data.payer_name = invoice.payerName;
+  if (invoice.invoiceNumber !== void 0) data.invoice_number = invoice.invoiceNumber;
+  if (invoice.paymentDueDate !== void 0) {
+    if (!isValidDate(invoice.paymentDueDate)) {
+      throw new DPayValueError("Payment due date must be in YYYY-MM-DD format");
+    }
+    data.payment_due_date = invoice.paymentDueDate;
+  }
+  if (invoice.vatAmount !== void 0) data.vat_amount = invoice.vatAmount.minor;
+  return data;
+}
+function serializePayoutInstruction(payout) {
+  if (payout.positions.length === 0) {
+    throw new DPayValueError("Payout instruction requires at least one position");
+  }
+  const feeMode = payout.feeMode ?? PayoutFeeMode.NET;
+  assertPayoutFeeMode(feeMode);
+  return {
+    fee_mode: feeMode,
+    positions: payout.positions.map((position) => {
+      if (position.iban === "") throw new DPayValueError("Payout IBAN must not be empty");
+      if (position.title === "" || position.title.length > 255) {
+        throw new DPayValueError("Payout title must be 1-255 characters");
+      }
+      return { iban: position.iban, title: position.title, amount: Number(position.amount.toDecimal()) };
+    })
+  };
+}
+
+// src/card/params.ts
+function serializeCardPayment(params) {
+  const body = {};
+  if (params.email !== void 0) body.email = params.email;
+  if (params.channelId !== void 0) body.channelId = params.channelId;
+  if (params.cardHolderFirstName !== void 0) body.cardHolderFirstName = params.cardHolderFirstName;
+  if (params.cardHolderLastName !== void 0) body.cardHolderLastName = params.cardHolderLastName;
+  if (params.encryptedCardData !== void 0) body.encryptedCardData = params.encryptedCardData;
+  body.deviceInfo = serializeDeviceInfo(params.deviceInfo);
+  if (params.threeDsConfirmed !== void 0) body.threeDsConfirmed = params.threeDsConfirmed;
+  if (params.dccDecision !== void 0) {
+    assertDccDecision(params.dccDecision);
+    body.dccDecision = params.dccDecision;
+  }
+  return body;
+}
+function serializeGooglePay(params) {
+  const body = {};
+  if (params.email !== void 0) body.email = params.email;
+  if (params.channelId !== void 0) body.channelId = params.channelId;
+  body.xPayType = "GOOGLE_PAY";
+  body.xPayToken = params.token;
+  body.deviceInfo = serializeDeviceInfo(params.deviceInfo);
+  return body;
+}
+function serializeApplePay(params) {
+  const body = {};
+  if (params.channelId !== void 0) body.channelId = params.channelId;
+  body.xPayType = params.token === void 0 ? "APPLE_PAY_INIT" : "APPLE_PAY";
+  if (params.token !== void 0) body.xPayToken = params.token;
+  body.deviceInfo = serializeDeviceInfo(params.deviceInfo);
+  return body;
+}
+
+// src/card/ops.ts
+function publicKeyOperation() {
+  return {
+    method: "GET",
+    host: API_PAYMENTS,
+    path: "/api/v1_0/cards/public-key",
+    parse: (response) => response.body.trim()
+  };
+}
+function paymentOperation(transactionId, suffix, body) {
+  return {
+    method: "POST",
+    host: API_PAYMENTS,
+    path: `/api/v1_0/cards/payment/${encodeURIComponent(transactionId)}${suffix}`,
+    body,
+    parse: parseResult
+  };
+}
+function parseResult(response) {
+  const data = decodeRecordOrFail(response);
+  if (data.success !== true) throw CardPaymentError.fromApi(data);
+  return parseCardPaymentResult(data);
+}
+function payOtpOperation(id, params) {
+  return paymentOperation(id, "/pay/card-otp", serializeCardPayment(params));
+}
+function preAuthOperation(id, params) {
+  return paymentOperation(id, "/pay/card-pre-auth", serializeCardPayment(params));
+}
+function captureOperation(id, amount2) {
+  return paymentOperation(id, "/capture", amountBody(amount2));
+}
+function cancelOperation(id, amount2) {
+  return paymentOperation(id, "/cancellation", amountBody(amount2));
+}
+function googlePayOperation(id, params) {
+  return paymentOperation(id, "/pay/google-pay", serializeGooglePay(params));
+}
+function applePayOperation(id, params) {
+  return paymentOperation(id, "/pay/apple-pay", serializeApplePay(params));
+}
+function amountBody(amount2) {
+  return amount2 === void 0 ? {} : { amount: Number(amount2.toDecimal()) };
+}
+
+// src/card/service.ts
+var CardService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /** Current RSA public key. dpay rotates it, so fetch it before every attempt. */
+  async publicKey(options) {
+    return this.api.execute(publicKeyOperation(), options);
+  }
+  /** Charges a card immediately. */
+  async payOtp(transactionId, params, options) {
+    return this.api.execute(payOtpOperation(transactionId, params), options);
+  }
+  /** Authorizes a card without capturing the funds. */
+  async preAuth(transactionId, params, options) {
+    return this.api.execute(preAuthOperation(transactionId, params), options);
+  }
+  /** Captures a pre-authorization. Omit `amount` to capture in full. */
+  async capture(transactionId, params, options) {
+    return this.api.execute(captureOperation(transactionId, params?.amount), options);
+  }
+  /** Cancels a pre-authorization. Omit `amount` to cancel in full. */
+  async cancel(transactionId, params, options) {
+    return this.api.execute(cancelOperation(transactionId, params?.amount), options);
+  }
+  /** Pays with a Google Pay token. */
+  async googlePay(transactionId, params, options) {
+    return this.api.execute(googlePayOperation(transactionId, params), options);
+  }
+  /** Initialises an Apple Pay session, or pays when `token` is given. */
+  async applePay(transactionId, params, options) {
+    return this.api.execute(applePayOperation(transactionId, params), options);
+  }
+};
+
+// src/config.ts
+var KNOWN_OPTIONS = [
+  "service",
+  "secretHash",
+  "timeout",
+  "httpClient",
+  "baseUrls",
+  "onRequest",
+  "onResponse"
+];
+function ownOption(options, key) {
+  return Object.hasOwn(options, key) ? options[key] : void 0;
+}
+var DEFAULT_TIMEOUT = 3e4;
+var TIMEOUT_MESSAGE = 'Option "timeout" must be a positive integer number of milliseconds';
+function validateTimeoutMs(timeout) {
+  if (!Number.isInteger(timeout) || timeout < 1) {
+    throw new DPayValueError(TIMEOUT_MESSAGE);
+  }
+  return timeout;
+}
+var Config = class _Config {
+  service;
+  secretHash;
+  timeout;
+  httpClient;
+  baseUrls;
+  onRequest;
+  onResponse;
+  constructor(init) {
+    this.service = init.service;
+    this.secretHash = init.secretHash;
+    this.timeout = init.timeout;
+    this.httpClient = init.httpClient;
+    this.baseUrls = init.baseUrls;
+    this.onRequest = init.onRequest;
+    this.onResponse = init.onResponse;
+    Object.freeze(this);
+  }
+  static fromOptions(options) {
+    const snapshot = Object.fromEntries(Object.entries(options));
+    for (const key of Object.keys(snapshot)) {
+      if (!KNOWN_OPTIONS.includes(key)) {
+        throw new DPayValueError(`Unknown option "${key}"`);
+      }
+    }
+    const service = ownOption(snapshot, "service");
+    if (typeof service !== "string" || service === "") {
+      throw new DPayValueError('Option "service" is required and must be a non-empty string');
+    }
+    const secretHash = ownOption(snapshot, "secretHash");
+    if (typeof secretHash !== "string" || secretHash === "") {
+      throw new DPayValueError('Option "secretHash" is required and must be a non-empty string');
+    }
+    const timeout = validateTimeoutMs(ownOption(snapshot, "timeout") ?? DEFAULT_TIMEOUT);
+    const httpClient = ownOption(snapshot, "httpClient") ?? null;
+    if (httpClient !== null && typeof httpClient.request !== "function") {
+      throw new DPayValueError('Option "httpClient" must implement HttpClient');
+    }
+    const overrides = ownOption(snapshot, "baseUrls") ?? {};
+    if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
+      throw new DPayValueError('Option "baseUrls" must be an object');
+    }
+    for (const url of Object.values(overrides)) {
+      if (typeof url !== "string" || url === "") {
+        throw new DPayValueError("Base URLs must be non-empty strings");
+      }
+    }
+    for (const name of ["onRequest", "onResponse"]) {
+      const hook = ownOption(snapshot, name);
+      if (hook !== void 0 && typeof hook !== "function") {
+        throw new DPayValueError(`Option "${name}" must be a function`);
+      }
+    }
+    return new _Config({
+      service,
+      secretHash,
+      timeout,
+      httpClient,
+      baseUrls: new BaseUrls(overrides),
+      onRequest: ownOption(snapshot, "onRequest") ?? null,
+      onResponse: ownOption(snapshot, "onResponse") ?? null
+    });
+  }
+};
+
+// src/http/fetch-client.ts
+var FetchHttpClient = class {
+  fetchImpl;
+  constructor(fetchImpl = globalThis.fetch) {
+    this.fetchImpl = fetchImpl;
+  }
+  async request(request) {
+    let response;
+    try {
+      response = await this.fetchImpl(request.url, {
+        method: request.method,
+        headers: { ...request.headers },
+        ...request.body !== null ? { body: request.body } : {},
+        signal: request.signal ?? null,
+        redirect: "manual"
+      });
+    } catch (error) {
+      throw new TransportError("HTTP request failed", { cause: error });
+    }
+    let body;
+    try {
+      body = await response.text();
+    } catch (error) {
+      throw new TransportError("Unable to read the API response body", { cause: error });
+    }
+    const headers = {};
+    response.headers.forEach((value, name) => {
+      headers[name] = value;
+    });
+    return new ApiResponse(response.status, headers, body);
+  }
+};
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+var ChecksumCalculator = class {
+  secretHash;
+  constructor(secretHash) {
+    this.secretHash = secretHash;
+  }
+  secretSecond(service, fields) {
+    const parts = [service, this.secretHash, ...fields.map(phpStrval)];
+    return sha256(parts.join("|"));
+  }
+  orderedBody(values) {
+    const joined = values.map(phpStrval).join("|");
+    return sha256(`${joined}|${this.secretHash}`);
+  }
+};
+function sha256(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+// src/internal/error-mapper.ts
+function mapError(response) {
+  const status = response.status;
+  const rawBody = response.body;
+  const decoded = response.decodeJson();
+  const data = typeof decoded === "object" && decoded !== null && !Array.isArray(decoded) ? decoded : {};
+  let message = "Unexpected API error";
+  if (typeof data.message === "string") message = data.message;
+  else if (typeof data.msg === "string") message = data.msg;
+  const errorCode = typeof data.errorcode === "string" ? data.errorcode : null;
+  const fieldErrors = normalizeFieldErrors(data.errors);
+  if (status === 429) {
+    return new RateLimitError(
+      message,
+      status,
+      intHeader(response, "Retry-After"),
+      intHeader(response, "X-RateLimit-Limit"),
+      intHeader(response, "X-RateLimit-Remaining"),
+      rawBody
+    );
+  }
+  if (status === 401) return new AuthenticationError(message, status, errorCode, fieldErrors, rawBody);
+  if (status === 403) return new AccessDeniedError(message, status, errorCode, fieldErrors, rawBody);
+  if (status === 404) return new NotFoundError(message, status, errorCode, fieldErrors, rawBody);
+  if (status === 400 || status === 422) {
+    return new InvalidRequestError(message, status, errorCode, fieldErrors, rawBody);
+  }
+  if (status >= 500) return new ApiServerError(message, status, errorCode, fieldErrors, rawBody);
+  return new ApiError(message, status, errorCode, fieldErrors, rawBody);
+}
+function normalizeFieldErrors(errors) {
+  let entries;
+  if (Array.isArray(errors)) {
+    entries = errors.map((value, index) => [String(index), value]);
+  } else if (typeof errors === "object" && errors !== null) {
+    entries = Object.entries(errors);
+  } else {
+    return {};
+  }
+  const normalized = {};
+  for (const [field, messages] of entries) {
+    if (typeof messages === "string") {
+      normalized[phpStrval(field)] = [messages];
+    } else if (Array.isArray(messages)) {
+      normalized[phpStrval(field)] = messages.filter(isScalar).map(phpStrval);
+    }
+  }
+  return normalized;
+}
+function intHeader(response, name) {
+  const value = response.getHeader(name);
+  return value === null || !isNumeric(value) ? null : phpInt(value);
+}
+
+// src/internal/requestor.ts
+var USER_AGENT = `dpay-node-sdk/${SDK_VERSION} node/${process.versions.node}`;
+var REDACTED_KEYS = ["checksum", "encryptedCardData", "xPayToken"];
+var ApiRequestor = class {
+  service;
+  checksum;
+  config;
+  httpClient;
+  constructor(config, httpClient) {
+    this.config = config;
+    this.httpClient = httpClient;
+    this.service = config.service;
+    this.checksum = new ChecksumCalculator(config.secretHash);
+  }
+  async execute(operation, options) {
+    const request = this.buildRequest(operation, options);
+    this.notify(() => this.config.onRequest?.(redactRequest(request)));
+    let response;
+    try {
+      response = await this.httpClient.request(request);
+    } catch (error) {
+      if (error instanceof DPayError) throw error;
+      throw new TransportError("HTTP request failed", { cause: error });
+    }
+    this.notify(
+      () => this.config.onResponse?.({ status: response.status, url: request.url, body: response.body })
+    );
+    if (operation.raiseForStatus !== false && response.status >= 400) throw mapError(response);
+    return operation.parse(response);
+  }
+  buildRequest(operation, options) {
+    const url = this.config.baseUrls.resolve(operation.host) + operation.path;
+    const headers = { Accept: "application/json", "User-Agent": USER_AGENT };
+    let body = null;
+    if (operation.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      try {
+        body = phpJsonEncode(operation.body);
+      } catch (error) {
+        throw new TransportError("Unable to encode request body as JSON", {
+          cause: error
+        });
+      }
+    }
+    return { method: operation.method, url, headers, body, signal: this.resolveSignal(options) };
+  }
+  resolveSignal(options) {
+    const timeout = AbortSignal.timeout(validateTimeoutMs(options?.timeout ?? this.config.timeout));
+    return options?.signal === void 0 ? timeout : AbortSignal.any([options.signal, timeout]);
+  }
+  notify(emit) {
+    let outcome;
+    try {
+      outcome = emit();
+    } catch {
+      return;
+    }
+    if (isThenable(outcome)) outcome.then(noop, noop);
+  }
+};
+function noop() {
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function redactRequest(request) {
+  return {
+    method: request.method,
+    url: request.url,
+    headers: { ...request.headers },
+    body: redactBody(request.body)
+  };
+}
+function redactBody(body) {
+  if (body === null) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(body);
+  } catch {
+    return body;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return body;
+  try {
+    return phpJsonEncode(redactValue(decoded));
+  } catch {
+    return body;
+  }
+}
+function redactValue(value) {
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (typeof value !== "object" || value === null) return value;
+  const redacted = {};
+  for (const [key, nested] of Object.entries(value)) {
+    redacted[key] = REDACTED_KEYS.includes(key) ? "[redacted]" : redactValue(nested);
+  }
+  return redacted;
+}
+
+// src/ipn/request.ts
+async function readRawBody(request) {
+  if (typeof request === "string") return request;
+  if (request instanceof Uint8Array) return Buffer.from(request).toString("utf8");
+  if (typeof request !== "object" || request === null) {
+    throw new DPayValueError("Unsupported request object passed to the IPN verifier");
+  }
+  const candidate = request;
+  if (typeof candidate.text === "function") {
+    try {
+      return await candidate.text();
+    } catch (error) {
+      if (error instanceof DPayValueError) {
+        throw error;
+      }
+      throw new TransportError("Unable to read the request body", { cause: error });
+    }
+  }
+  if (typeof candidate[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    try {
+      for await (const chunk of request) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+      }
+    } catch (error) {
+      if (error instanceof DPayValueError) {
+        throw error;
+      }
+      throw new TransportError("Unable to read the request body", { cause: error });
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (text === "" && candidate.body !== void 0) {
+      throw new DPayValueError(
+        "The request body was already consumed by a body parser. Mount the IPN route before express.json(), for example with express.raw({ type: '*/*' }), and pass the raw Buffer instead."
+      );
+    }
+    return text;
+  }
+  throw new DPayValueError("Unsupported request object passed to the IPN verifier");
+}
+
+// src/ipn/event.ts
+var IpnType = { TRANSFER: "transfer", CAPTURE: "capture", DCB: "dcb" };
+var IPN_ACK = "OK";
+function buildIpnEvent(raw) {
+  const type = scalar(raw, "type") ?? "";
+  return Object.freeze({
+    id: scalar(raw, "id") ?? "",
+    amount: scalar(raw, "amount") ?? "",
+    email: scalar(raw, "email"),
+    type,
+    attempt: isNumeric(raw.attempt) ? phpInt(raw.attempt) : 0,
+    version: isNumeric(raw.version) ? phpInt(raw.version) : 0,
+    custom: scalar(raw, "custom"),
+    capturePaymentId: scalar(raw, "capture_payment_id"),
+    signature: scalar(raw, "signature") ?? "",
+    isTransfer: type === IpnType.TRANSFER,
+    isCapture: type === IpnType.CAPTURE,
+    isDcb: type === IpnType.DCB,
+    raw
+  });
+}
+function scalar(raw, key) {
+  const value = raw[key];
+  return isScalar(value) ? phpStrval(value) : null;
+}
+
+// src/ipn/verifier.ts
+var REQUIRED = ["id", "amount", "type", "attempt", "version", "signature"];
+function constructIpnEvent(rawBody, secretHash) {
+  const text = typeof rawBody === "string" ? rawBody : Buffer.from(rawBody).toString("utf8");
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch (error) {
+    throw new SignatureVerificationError("Invalid IPN payload", { cause: error });
+  }
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    throw new SignatureVerificationError("Invalid IPN payload");
+  }
+  const raw = payload;
+  for (const field of REQUIRED) {
+    if (raw[field] === void 0 || raw[field] === null) {
+      throw new SignatureVerificationError("Invalid IPN payload");
+    }
+  }
+  if (typeof raw.signature !== "string") throw new SignatureVerificationError("Invalid IPN payload");
+  const expected = expectedSignature(raw, secretHash);
+  const provided = Buffer.from(raw.signature, "utf8");
+  const wanted = Buffer.from(expected, "utf8");
+  if (provided.length !== wanted.length || !timingSafeEqual(provided, wanted)) {
+    throw new SignatureVerificationError("Invalid IPN signature");
+  }
+  return buildIpnEvent(raw);
+}
+function expectedSignature(raw, secretHash) {
+  const type = isScalar(raw.type) ? phpStrval(raw.type) : "";
+  const parts = [
+    isScalar(raw.id) ? phpStrval(raw.id) : "",
+    secretHash,
+    isScalar(raw.amount) ? phpStrval(raw.amount) : ""
+  ];
+  if (type !== IpnType.DCB) parts.push(isScalar(raw.email) ? phpStrval(raw.email) : "");
+  parts.push(type);
+  parts.push(isNumeric(raw.attempt) ? phpStrval(raw.attempt) : "0");
+  parts.push(isNumeric(raw.version) ? phpStrval(raw.version) : "0");
+  parts.push(isScalar(raw.custom) ? phpStrval(raw.custom) : "");
+  return createHash("sha256").update(parts.join(""), "utf8").digest("hex");
+}
+
+// src/ipn/service.ts
+var IpnService = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Verifies an IPN body. Uses the client's `secretHash` unless one is given. */
+  constructEvent(rawBody, secretHash) {
+    return constructIpnEvent(rawBody, secretHash ?? this.config.secretHash);
+  }
+  /** Reads and verifies an IPN straight from an incoming HTTP request. */
+  async constructEventFromRequest(request, secretHash) {
+    return constructIpnEvent(await readRawBody(request), secretHash ?? this.config.secretHash);
+  }
+};
+
+// src/blik/params.ts
+var FREQUENCY = /^[1-9][0-9]{0,2}[DWMQY]$/;
+var MODELS = ["A", "M", "O"];
+function serializeBlikAliasRegistration(params) {
+  assertLabel(params.label, "Alias label must be 1-50 characters");
+  const type = params.type ?? BlikAliasType.UID;
+  assertBlikAliasType(type);
+  return { label: params.label, type };
+}
+function serializeBlikRecurringRegistration(params) {
+  assertLabel(params.label, "Alias label must be 1-50 characters");
+  if (!MODELS.includes(params.model)) {
+    throw new DPayValueError(`Invalid recurring model "${params.model}"`);
+  }
+  if (!FREQUENCY.test(params.frequency)) {
+    throw new DPayValueError(`Invalid recurring frequency "${params.frequency}"`);
+  }
+  const data = {
+    label: params.label,
+    type: BlikAliasType.PAYID,
+    model: params.model,
+    frequency: params.frequency
+  };
+  if (params.value !== void 0) data.value = params.value.toDecimal();
+  if (params.limitAmt !== void 0) data.limit_amt = params.limitAmt;
+  if (params.totLimitAmt !== void 0) data.tot_limit_amt = params.totLimitAmt;
+  if (params.limitAmtFixed !== void 0) data.is_limit_amt_fixed = params.limitAmtFixed;
+  if (params.expirationDate !== void 0) data.expiration_date = assertDate(params.expirationDate);
+  if (params.initDate !== void 0) data.init_date = assertDate(params.initDate);
+  return data;
+}
+function assertLabel(label, message) {
+  if (label === "" || label.length > 50) throw new DPayValueError(message);
+}
+
+// src/card/recurring-params.ts
+function serializeCardRecurringRegistration(params) {
+  if (params.label === "" || params.label.length > 50) {
+    throw new DPayValueError("Mandate label must be 1-50 characters");
+  }
+  const data = { label: params.label };
+  if (params.frequency !== void 0) {
+    assertCardRecurringFrequency(params.frequency);
+    data.frequency = params.frequency;
+  }
+  if (params.limitAmt !== void 0) data.limit_amt = params.limitAmt.minor;
+  if (params.totLimitAmt !== void 0) data.tot_limit_amt = params.totLimitAmt.minor;
+  if (params.limitAmtFixed !== void 0) data.is_limit_amt_fixed = params.limitAmtFixed;
+  if (params.expirationDate !== void 0) data.expiration_date = assertDate(params.expirationDate);
+  if (params.initDate !== void 0) data.init_date = assertDate(params.initDate);
+  return data;
+}
+
+// src/payment/register-body.ts
+var PARTNER_PLATFORM = /^[A-Z0-9]{1,64}$/;
+var BLIK_CODE = /^\d{6}$/;
+function buildRegisterBody(service, params) {
+  assertTransactionType(params.transactionType);
+  assertExclusions(params);
+  const body = {
+    service,
+    value: params.amount.toDecimal(),
+    transactionType: params.transactionType,
+    url_success: assertUrl(params.urls.success, "success"),
+    url_fail: assertUrl(params.urls.fail, "fail"),
+    url_ipn: assertUrl(params.urls.ipn, "ipn")
+  };
+  if (params.description !== void 0) body.description = params.description;
+  if (params.custom !== void 0) body.custom = params.custom;
+  if (params.payer?.email !== void 0) {
+    if (!isValidEmail(params.payer.email)) throw new DPayValueError(`Invalid email "${params.payer.email}"`);
+    body.email = params.payer.email;
+  }
+  if (params.payer?.firstName !== void 0) body.client_name = params.payer.firstName;
+  if (params.payer?.lastName !== void 0) body.client_surname = params.payer.lastName;
+  if (params.acceptTos !== void 0) body.accept_tos = params.acceptTos;
+  if (params.channel !== void 0) body.channel = params.channel;
+  const toggles = [
+    ["creditcard", params.creditCard],
+    ["paysafecard", params.paysafecard],
+    ["blik", params.blik],
+    ["installment", params.installment],
+    ["paypal", params.paypal],
+    ["nobanks", params.noBanks]
+  ];
+  for (const [key, flag2] of toggles) {
+    if (flag2 !== void 0) body[key] = flag2 ? 1 : 0;
+  }
+  if (params.phoneNumber !== void 0) body.phone_number = params.phoneNumber;
+  if (params.currencyCode !== void 0) {
+    assertCurrency(params.currencyCode);
+    body.currency_code = params.currencyCode;
+  }
+  if (params.partnerPlatform !== void 0) {
+    if (!PARTNER_PLATFORM.test(params.partnerPlatform)) {
+      throw new DPayValueError("Partner platform must match ^[A-Z0-9]{1,64}$");
+    }
+    body.partner_platform = params.partnerPlatform;
+  }
+  if (params.userAgent !== void 0) body.user_agent = params.userAgent;
+  if (params.userIp !== void 0) body.user_ip = params.userIp;
+  if (params.blikCode !== void 0) {
+    if (!BLIK_CODE.test(params.blikCode)) throw new DPayValueError("BLIK code must be exactly 6 digits");
+    body.blik_code = params.blikCode;
+  }
+  if (params.blikAlias !== void 0) body.blik_alias = params.blikAlias;
+  if (params.registerBlikAlias !== void 0) {
+    body.register_blik_alias = serializeBlikAliasRegistration(params.registerBlikAlias);
+  }
+  if (params.registerBlikRecurringAlias !== void 0) {
+    body.register_blik_recurring_alias = serializeBlikRecurringRegistration(params.registerBlikRecurringAlias);
+  }
+  if (params.aliasIpnUrl !== void 0) {
+    if (!isValidUrl(params.aliasIpnUrl)) {
+      throw new DPayValueError(`Invalid alias IPN URL "${params.aliasIpnUrl}"`);
+    }
+    body.alias_ipn_url = params.aliasIpnUrl;
+  }
+  if (params.noDelay !== void 0) body.no_delay = params.noDelay;
+  if (params.registerCardRecurring !== void 0) {
+    body.register_card_recurring = serializeCardRecurringRegistration(params.registerCardRecurring);
+  }
+  if (params.cardRecurringAlias !== void 0) body.card_recurring_alias = params.cardRecurringAlias;
+  if (params.authorizeOnly !== void 0) body.authorize_only = params.authorizeOnly;
+  if (params.cardRecurringOperation !== void 0) {
+    assertCardRecurringOperation(params.cardRecurringOperation);
+    body.card_recurring_operation = params.cardRecurringOperation;
+  }
+  if (params.payout !== void 0) body.payout = serializePayoutInstruction(params.payout);
+  if (params.billingAddress !== void 0) body.billing_address = { ...params.billingAddress };
+  if (params.shippingAddress !== void 0) body.shipping_address = { ...params.shippingAddress };
+  if (params.deviceInfo !== void 0) body.device_info = serializeDeviceInfo(params.deviceInfo);
+  if (params.products !== void 0) body.products = params.products.map((product) => ({ ...product }));
+  if (params.efaktura !== void 0) body.efaktura = params.efaktura;
+  if (params.invoice !== void 0) body.invoice = serializeInvoice(params.invoice);
+  return body;
+}
+function assertExclusions(params) {
+  if (params.blikCode !== void 0 && params.blikAlias !== void 0) {
+    throw new DPayValueError("blik_code cannot be combined with blik_alias");
+  }
+  if (params.blikAlias !== void 0 && (params.registerBlikAlias !== void 0 || params.registerBlikRecurringAlias !== void 0)) {
+    throw new DPayValueError("blik_alias cannot be combined with blik_code or alias registration");
+  }
+  if (params.registerCardRecurring !== void 0 && params.cardRecurringAlias !== void 0) {
+    throw new DPayValueError("register_card_recurring cannot be combined with card_recurring_alias");
+  }
+  if (params.efaktura === true && params.transactionType !== "transfers") {
+    throw new DPayValueError('efaktura is allowed only for transactionType "transfers"');
+  }
+  if ((params.blikCode !== void 0 || params.blikAlias !== void 0) && (params.userAgent === void 0 || params.userIp === void 0)) {
+    throw new DPayValueError("blik_code and blik_alias require user_agent and user_ip");
+  }
+  if (params.phoneNumber !== void 0 && params.currencyCode === void 0) {
+    throw new DPayValueError("phone_number requires currency_code");
+  }
+}
+function assertUrl(url, name) {
+  if (!isValidUrl(url)) throw new DPayValueError(`Invalid ${name} URL "${url}"`);
+  return url;
+}
+
+// src/payment/ops.ts
+function registerOperation(service, checksum, params) {
+  const body = buildRegisterBody(service, params);
+  body.checksum = checksum.secretSecond(service, [
+    stringField(body, "value"),
+    stringField(body, "url_success"),
+    stringField(body, "url_fail"),
+    stringField(body, "url_ipn")
+  ]);
+  return {
+    method: "POST",
+    host: API_PAYMENTS,
+    path: "/api/v1_0/payments/register",
+    body,
+    parse: parseRegisterResponse
+  };
+}
+function parseRegisterResponse(response) {
+  const data = decodeRecordOrFail(response);
+  if (data.error === true || data.status === false) throw PaymentRejectedError.fromApi(data);
+  return parseRegisteredPayment(data);
+}
+function detailsOperation(service, checksum, transactionId) {
+  const body = { service, transaction_id: transactionId };
+  body.checksum = checksum.orderedBody(Object.values(body));
+  return {
+    method: "POST",
+    host: PANEL,
+    path: "/api/v1/pbl/details",
+    body,
+    parse: (response) => parseTransaction(decodeRecordOrFail(response))
+  };
+}
+function stringField(body, key) {
+  const value = body[key];
+  return isScalar(value) ? phpStrval(value) : "";
+}
+
+// src/payment/service.ts
+var PaymentService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /**
+   * Registers a payment and returns the redirect target.
+   * Throws `PaymentRejectedError` when dpay rejects it with HTTP 200.
+   */
+  async register(params, options) {
+    return this.api.execute(registerOperation(this.api.service, this.api.checksum, params), options);
+  }
+  /** Reads the current state of a transaction, including its refunds. */
+  async details(transactionId, options) {
+    return this.api.execute(detailsOperation(this.api.service, this.api.checksum, transactionId), options);
+  }
+};
+
+// src/payout/models.ts
+function parsePayoutDetails(data) {
+  const state = isScalar(data.state) ? phpInt(data.state) : 0;
+  const receiver = record(data.receiver);
+  return Object.freeze({
+    id: isScalar(data.id) ? phpInt(data.id) : 0,
+    state,
+    net: moneyOrZero(data, "net"),
+    fee: moneyOrZero(data, "fee"),
+    gross: moneyOrZero(data, "gross"),
+    creationDate: strictString(data, "creation_date"),
+    isDirectSettlement: flag(data, "direct_settlement"),
+    nrb: strictString(data, "nrb"),
+    isDeclined: flag(data, "declined"),
+    declineReason: strictString(data, "decline_reason"),
+    declineStatus: strictString(data, "decline_status"),
+    receiver: receiver === null ? null : parsePayoutReceiver(receiver),
+    isWaiting: state === 0,
+    isProcessed: state === 1,
+    isFailed: state === -1,
+    raw: data
+  });
+}
+function parsePayoutReceiver(data) {
+  return Object.freeze({
+    nrb: strictString(data, "nrb"),
+    title: strictString(data, "title"),
+    amount: Money.tryFromApiNumber(data.amount, Currency.PLN),
+    service: strictString(data, "service"),
+    receiverName: strictString(data, "receiverName"),
+    receiverAddress: strictString(data, "receiverAddress"),
+    raw: data
+  });
+}
+function flag(data, key) {
+  const value = data[key];
+  return isScalar(value) ? phpInt(value) === 1 : false;
+}
+
+// src/payout/ops.ts
+function payoutDetailsOperation(service, checksum, params) {
+  const body = { service };
+  if (params.timestamp !== void 0) body.timestamp = params.timestamp;
+  body.withdraw_id = params.withdrawId;
+  body.checksum = checksum.orderedBody(Object.values(body));
+  return {
+    method: "POST",
+    host: PANEL,
+    path: "/api/v1/pbl/withdraws/details",
+    body,
+    parse: (response) => parsePayoutDetails(decodeRecordOrFail(response))
+  };
+}
+
+// src/payout/service.ts
+var PayoutService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /** Reads the state of a single payout. */
+  async details(params, options) {
+    return this.api.execute(payoutDetailsOperation(this.api.service, this.api.checksum, params), options);
+  }
+};
+
+// src/refund/models.ts
+function parseRefund(data) {
+  return Object.freeze({
+    isAccepted: data.status === "success" && data.refund === true,
+    message: scalarStringOrNull(data, "message"),
+    raw: data
+  });
+}
+function parseRefundAvailability(data, httpStatus) {
+  return Object.freeze({
+    isAvailable: data.refund === true,
+    message: scalarStringOrNull(data, "message"),
+    httpStatus,
+    raw: data
+  });
+}
+
+// src/refund/ops.ts
+var AVAILABILITY_OUTCOMES = [200, 400, 402, 406, 409, 410, 411];
+function signedBody(service, checksum, params) {
+  const body = { service, transaction_id: params.transactionId };
+  if (params.amount !== void 0) body.value = params.amount.toDecimal();
+  if (params.reason !== void 0) body.reason = params.reason;
+  body.checksum = checksum.orderedBody(Object.values(body));
+  return body;
+}
+function createRefundOperation(service, checksum, params) {
+  return {
+    method: "POST",
+    host: PANEL,
+    path: "/api/v1/pbl/refund",
+    body: signedBody(service, checksum, params),
+    parse: (response) => parseRefund(decodeRecordOrFail(response))
+  };
+}
+function checkAvailabilityOperation(service, checksum, params) {
+  return {
+    method: "POST",
+    host: PANEL,
+    path: "/api/v1/pbl/check-refund-availability",
+    body: signedBody(service, checksum, params),
+    raiseForStatus: false,
+    parse: parseAvailability
+  };
+}
+function parseAvailability(response) {
+  const json = response.decodeJson();
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    const data = json;
+    if (Object.hasOwn(data, "refund") && isOutcome(response.status, data)) {
+      return parseRefundAvailability(data, response.status);
+    }
+  }
+  throw mapError(response);
+}
+function isOutcome(status, data) {
+  if (AVAILABILITY_OUTCOMES.includes(status)) return true;
+  return status === 401 && data.message !== "Unauthorized request";
+}
+
+// src/refund/service.ts
+var RefundService = class {
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  /** Refunds a transaction in full, or partially when `amount` is given. */
+  async create(params, options) {
+    return this.api.execute(createRefundOperation(this.api.service, this.api.checksum, params), options);
+  }
+  /**
+   * Checks whether a refund would be accepted, without performing it.
+   * Refusal arrives as a 4xx status carrying an outcome body, not as an error.
+   */
+  async checkAvailability(params, options) {
+    return this.api.execute(checkAvailabilityOperation(this.api.service, this.api.checksum, params), options);
+  }
+};
+
+// src/client.ts
+var DPayClient = class {
+  /** Version of this SDK. */
+  VERSION = SDK_VERSION;
+  /** Register payments and read transaction state. */
+  payments;
+  /** Refund transactions and check refund availability. */
+  refunds;
+  /** List banks available on the payment page. */
+  banks;
+  /** Register, unregister and inspect BLIK aliases. */
+  blik;
+  /** Server-to-server card payments, wallets and pre-authorizations. */
+  cards;
+  /** Read the state of payouts. */
+  payouts;
+  /** Verify incoming IPN notifications. */
+  ipn;
+  /**
+   * Validates `options` eagerly - before any network call - and mounts every service on
+   * top of a shared transport. Defaults to `FetchHttpClient` when `options.httpClient` is
+   * not given.
+   */
+  constructor(options) {
+    const config = Config.fromOptions(options);
+    const transport = config.httpClient ?? new FetchHttpClient();
+    const api = new ApiRequestor(config, transport);
+    this.payments = new PaymentService(api);
+    this.refunds = new RefundService(api);
+    this.banks = new BankService(api);
+    this.blik = new BlikService(api);
+    this.cards = new CardService(api);
+    this.payouts = new PayoutService(api);
+    this.ipn = new IpnService(config);
+  }
+};
+var PAN = /^\d{12,19}$/;
+var CVV = /^\d{3,4}$/;
+var EXPIRY = /^(0[1-9]|1[0-2])\/\d{2}$/;
+var CardData = class {
+  /** Card number, normalized to digits only (spaces stripped). */
+  #pan;
+  /** Card verification value, 3-4 digits. */
+  #cvv;
+  /** Expiry in `MM/YY` format. */
+  #expiry;
+  constructor(params) {
+    const pan = params.pan.replaceAll(" ", "");
+    if (!PAN.test(pan)) throw new DPayValueError("Card number must be 12-19 digits");
+    if (!CVV.test(params.cvv)) throw new DPayValueError("CVV must be 3-4 digits");
+    if (!EXPIRY.test(params.expiry)) throw new DPayValueError("Expiry must be in MM/YY format");
+    this.#pan = pan;
+    this.#cvv = params.cvv;
+    this.#expiry = params.expiry;
+    Object.freeze(this);
+  }
+  /** Card number, normalized to digits only (spaces stripped). */
+  get pan() {
+    return this.#pan;
+  }
+  /** Card verification value, 3-4 digits. */
+  get cvv() {
+    return this.#cvv;
+  }
+  /** Expiry in `MM/YY` format. */
+  get expiry() {
+    return this.#expiry;
+  }
+  redacted() {
+    return { pan: `****${this.#pan.slice(-4)}`, cvv: "***", expiry: this.#expiry };
+  }
+  /** Redacted representation - `pan` masked to its last 4 digits, `cvv` fully masked. */
+  toJSON() {
+    return this.redacted();
+  }
+  /** Redacted representation - `pan` masked to its last 4 digits, `cvv` fully masked. */
+  toString() {
+    const { pan, cvv, expiry } = this.redacted();
+    return `CardData(pan='${pan}', cvv='${cvv}', expiry='${expiry}')`;
+  }
+  /** Node `util.inspect` hook - delegates to the same redacted `toString()`. */
+  [inspect.custom]() {
+    return this.toString();
+  }
+};
+var CardEncryptor = class {
+  /**
+   * Returns the Base64 payload to put in `encryptedCardData`.
+   * Fetch the public key immediately before every attempt - dpay rotates it.
+   */
+  encrypt(card, transactionId, publicKeyPem) {
+    let key;
+    try {
+      key = createPublicKey(publicKeyPem);
+    } catch (error) {
+      throw new CardEncryptionError("Invalid RSA public key", { cause: error });
+    }
+    const payload = phpJsonEncode(
+      {
+        PN: card.pan,
+        SC: card.cvv,
+        DT: card.expiry,
+        ID: transactionId,
+        TX: Math.floor(Date.now() / 1e3)
+      },
+      { escapeSlashes: true }
+    );
+    try {
+      return publicEncrypt(
+        { key, padding: constants.RSA_PKCS1_PADDING },
+        Buffer.from(payload, "utf8")
+      ).toString("base64");
+    } catch (error) {
+      throw new CardEncryptionError("Card data encryption failed", { cause: error });
+    }
+  }
+};
+
+export { AccessDeniedError, ApiError, ApiServerError, AuthenticationError, BlikAliasType, CardData, CardEncryptionError, CardEncryptor, CardPaymentError, CardRecurringFrequency, CardRecurringOperation, Currency, DEFAULT_TIMEOUT, DPayClient, DPayError, DPayValueError, DccDecision, FetchHttpClient, IPN_ACK, InvalidRequestError, IpnType, Money, NotFoundError, PaymentRejectedError, PayoutFeeMode, RateLimitError, RedirectType, SDK_VERSION, SignatureVerificationError, TransactionStatus, TransactionType, TransportError, assertCurrency, constructIpnEvent, isValidCurrency, readRawBody };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map