liqpay-nestjs 0.3.4 → 0.3.5

package/dist/core/types/checkout/checkout.callback.d.ts

@@ -1,6 +1,12 @@
 import { z } from 'zod';
 /**
- * Contract of decoded format of API parameters received in a request from LiqPay after payment
+ * Raw (non-normalized) LiqPay checkout callback payload.
+ *
+ * ⚠️ Notes:
+ * - All fields are in snake_case
+ * - Types are inconsistent (string | number | boolean)
+ * - Some fields may be missing depending on payment flow
+ * - Should NOT be used directly in application logic
  */
 export declare const RawCheckoutCallbackSchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
@@ -62,9 +68,20 @@ export declare const RawCheckoutCallbackSchema: z.ZodObject<{
     refund_amount: z.ZodOptional<z.ZodNumber>;
     verifycode: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Type of raw LiqPay callback.
+ */
 export type RawCheckoutCallback = z.infer<typeof RawCheckoutCallbackSchema>;
 /**
- * Contract of decoded format of API parameters received in a request from LiqPay after payment
+ * Normalized checkout callback.
+ *
+ * What this schema does:
+ * - Converts keys from snake_case → camelCase
+ * - Normalizes types (string → number/date/boolean)
+ * - Validates enums
+ * - Removes undefined fields
+ *
+ * Safe to use in business logic.
  */
 export declare const CheckoutCallbackSchema: z.ZodPipe<z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
@@ -316,6 +333,9 @@ export declare const CheckoutCallbackSchema: z.ZodPipe<z.ZodObject<{
     verifycode?: string | undefined;
 }>>;
 /**
- * Contract of decoded format of API parameters received in a request from LiqPay after payment
+ * Type of normalized checkout callback.
+ * - Fully parsed
+ * - Type-safe
+ * - Ready for backend logic
  */
 export type CheckoutCallback = z.infer<typeof CheckoutCallbackSchema>;

package/dist/core/types/checkout/checkout.callback.js

@@ -8,7 +8,13 @@ const enums_1 = require("../common/enums");
 const error_1 = require("../error");
 // TODO: check for optional fields on real api callbacks
 /**
- * Contract of decoded format of API parameters received in a request from LiqPay after payment
+ * Raw (non-normalized) LiqPay checkout callback payload.
+ *
+ * ⚠️ Notes:
+ * - All fields are in snake_case
+ * - Types are inconsistent (string | number | boolean)
+ * - Some fields may be missing depending on payment flow
+ * - Should NOT be used directly in application logic
  */
 exports.RawCheckoutCallbackSchema = zod_1.z.object({
     /**
@@ -257,7 +263,15 @@ exports.RawCheckoutCallbackSchema = zod_1.z.object({
     verifycode: zod_1.z.string().optional(),
 });
 /**
- * Contract of decoded format of API parameters received in a request from LiqPay after payment
+ * Normalized checkout callback.
+ *
+ * What this schema does:
+ * - Converts keys from snake_case → camelCase
+ * - Normalizes types (string → number/date/boolean)
+ * - Validates enums
+ * - Removes undefined fields
+ *
+ * Safe to use in business logic.
  */
 exports.CheckoutCallbackSchema = exports.RawCheckoutCallbackSchema.transform(raw => {
     const camelized = (0, ts_case_convert_1.objectToCamel)(raw);

package/dist/core/types/checkout/checkout.request.d.ts

@@ -1,7 +1,7 @@
 import z from 'zod';
 import { CheckoutAction, LiqPayVersion } from '../common/enums';
 /**
- * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ * Input data for checkout (payment creation). This is the main payload provided by the user.
  */
 export declare const CheckoutInputSchema: z.ZodObject<{
     amount: z.ZodNumber;
@@ -124,11 +124,13 @@ export declare const CheckoutInputSchema: z.ZodObject<{
     productUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
- * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ * Type of checkout input.
  */
 export type CheckoutInput = z.infer<typeof CheckoutInputSchema>;
 /**
- * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ * Full checkout request (before serialization).
+ *
+ * Extends {@link CheckoutInput} with required LiqPay API fields.
  */
 export type CheckoutRequest = CheckoutInput & {
     /**
@@ -150,6 +152,16 @@ export type CheckoutRequest = CheckoutInput & {
      */
     action: CheckoutAction;
 };
+/**
+ * Raw checkout request (snake_case).
+ *
+ * ⚠️ Notes:
+ * - Converts camelCase → snake_case
+ * - Applies LiqPay-specific formatting
+ * - Removes undefined fields
+ *
+ * Used right before sending request to LiqPay.
+ */
 export declare const RawCheckoutRequestSchema: z.ZodPipe<z.ZodCustom<CheckoutRequest, CheckoutRequest>, z.ZodTransform<Partial<{
     /**
      * Data for fiscalization (rro_info)
@@ -250,4 +262,10 @@ export declare const RawCheckoutRequestSchema: z.ZodPipe<z.ZodCustom<CheckoutReq
     public_key: string;
     action: CheckoutAction;
 }>, CheckoutRequest>>;
+/**
+ * Type of raw checkout request.
+ * - snake_case
+ * - formatted for LiqPay
+ * - ready to be encoded (base64 + signature)
+ */
 export type RawCheckoutRequest = z.infer<typeof RawCheckoutRequestSchema>;

package/dist/core/types/checkout/checkout.request.js

@@ -10,7 +10,7 @@ const utils_1 = require("../../utils");
 const common_1 = require("../common");
 const enums_1 = require("../common/enums");
 /**
- * Contract of data that is passed when forming a payment request as `base64` encoded string data when calling the LiqPay API
+ * Input data for checkout (payment creation). This is the main payload provided by the user.
  */
 exports.CheckoutInputSchema = zod_1.default.object({
     /**
@@ -150,10 +150,20 @@ exports.CheckoutInputSchema = zod_1.default.object({
      */
     productUrl: zod_1.default.string().max(510).optional(),
 });
+/**
+ * Raw checkout request (snake_case).
+ *
+ * ⚠️ Notes:
+ * - Converts camelCase → snake_case
+ * - Applies LiqPay-specific formatting
+ * - Removes undefined fields
+ *
+ * Used right before sending request to LiqPay.
+ */
 exports.RawCheckoutRequestSchema = zod_1.default
     .custom()
-    .transform(req => {
-    const { fiscalData, verifyCode, recurringByToken, detailAddenda, ...rest } = req;
+    .transform(request => {
+    const { fiscalData, verifyCode, recurringByToken, detailAddenda, ...rest } = request;
     const snakelized = (0, ts_case_convert_1.objectToSnake)(rest);
     const transformed = {
         ...snakelized,

package/dist/core/types/common/enums/action.schema.d.ts

@@ -42,5 +42,7 @@ export declare const ActionSchema: z.ZodEnum<{
 }>;
 export type Action = z.infer<typeof ActionSchema>;
 export type CheckoutAction = Extract<Action, 'pay' | 'hold' | 'subscribe' | 'paydonate'>;
+export type PaymentStatusAction = Extract<Action, 'status'>;
+export type RefundAction = Extract<Action, 'refund'>;
 export type VerificationAction = Extract<Action, 'confirm' | 'mpi' | 'cardverification'>;
 export type ReportAction = Extract<Action, 'reports' | 'reports_compensation' | 'register' | 'reports_compensation_file' | 'reports_compensation_file_status'>;

package/dist/core/types/payment-status/payment-status.request.d.ts

@@ -1,17 +1,19 @@
 import z from 'zod';
-import { Action, LiqPayVersion } from '../common/enums';
+import { LiqPayVersion, PaymentStatusAction } from '../common/enums';
 /**
- * Schema of data that is passed when forming a request to receive payment status as data in `base64` encoded string form when calling the LiqPay API
+ * Input data for retrieving payment status. Minimal payload required from the user.
  */
 export declare const PaymentStatusInputSchema: z.ZodObject<{
     orderId: z.ZodString;
 }, z.core.$strip>;
 /**
- * Contract of data that is passed when forming a request to receive payment status as data in `base64` encoded string form when calling the LiqPay API
+ * Type of payment status input.
  */
 export type PaymentStatusInput = z.infer<typeof PaymentStatusInputSchema>;
 /**
- * Schema of data that is passed when forming a request to receive payment status as data in `base64` encoded string form when calling the LiqPay API
+ * Full payment status request (before serialization).
+ *
+ * Extends {@link PaymentStatusInput} with required LiqPay API fields.
  */
 export type PaymentStatusRequest = PaymentStatusInput & {
     /**
@@ -27,12 +29,27 @@ export type PaymentStatusRequest = PaymentStatusInput & {
     /**
      * Operation type. Possible values: `status`
      */
-    action: Extract<Action, 'status'>;
+    action: PaymentStatusAction;
 };
+/**
+ * Raw payment status request (snake_case).
+ *
+ * ⚠️ Notes:
+ * - Converts camelCase → snake_case
+ * - Does NOT modify values
+ * - Does NOT perform validation
+ *
+ * Used before sending request to LiqPay API.
+ */
 export declare const RawPaymentStatusRequestSchema: z.ZodPipe<z.ZodCustom<PaymentStatusRequest, PaymentStatusRequest>, z.ZodTransform<{
     order_id: string;
     version: LiqPayVersion;
     public_key: string;
-    action: Extract<Action, "status">;
+    action: PaymentStatusAction;
 }, PaymentStatusRequest>>;
+/**
+ * Type of raw payment status request.
+ * - snake_case
+ * - ready for encoding and sending to LiqPay
+ */
 export type RawPaymentStatusRequest = z.infer<typeof RawPaymentStatusRequestSchema>;

package/dist/core/types/payment-status/payment-status.request.js

@@ -7,7 +7,7 @@ exports.RawPaymentStatusRequestSchema = exports.PaymentStatusInputSchema = void
 const ts_case_convert_1 = require("ts-case-convert");
 const zod_1 = __importDefault(require("zod"));
 /**
- * Schema of data that is passed when forming a request to receive payment status as data in `base64` encoded string form when calling the LiqPay API
+ * Input data for retrieving payment status. Minimal payload required from the user.
  */
 exports.PaymentStatusInputSchema = zod_1.default.object({
     /**
@@ -15,9 +15,19 @@ exports.PaymentStatusInputSchema = zod_1.default.object({
      */
     orderId: zod_1.default.string().max(255),
 });
+/**
+ * Raw payment status request (snake_case).
+ *
+ * ⚠️ Notes:
+ * - Converts camelCase → snake_case
+ * - Does NOT modify values
+ * - Does NOT perform validation
+ *
+ * Used before sending request to LiqPay API.
+ */
 exports.RawPaymentStatusRequestSchema = zod_1.default
     .custom()
-    .transform(typed => {
-    const snakelized = (0, ts_case_convert_1.objectToSnake)(typed);
+    .transform(request => {
+    const snakelized = (0, ts_case_convert_1.objectToSnake)(request);
     return { ...snakelized };
 });

package/dist/core/types/payment-status/payment-status.response.d.ts

@@ -1,6 +1,13 @@
 import { z } from 'zod';
 /**
- * Schema of data that comes in response to a request to get payment status
+ * Raw response from LiqPay `status` API.
+ *
+ * ⚠️ Important:
+ * - Field names are in `snake_case`
+ * - Types are inconsistent (`string | number | boolean`)
+ * - Dates are not parsed
+ *
+ * This schema reflects the API response **as-is**, without normalization.
  */
 export declare const RawPaymentStatusResponseSchema: z.ZodObject<{
     acq_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -56,11 +63,18 @@ export declare const RawPaymentStatusResponseSchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
- * Contract of data that comes in response to a request to get payment status
+ * Raw (unprocessed) payment status response.
  */
 export type RawPaymentStatusResponse = z.infer<typeof RawPaymentStatusResponseSchema>;
 /**
- * Schema of data that comes in response to a request to get payment status
+ * Normalized payment status response.
+ *
+ * This schema:
+ * - converts keys to `camelCase`
+ * - normalizes primitive types
+ * - parses dates
+ * - validates enums
+ * - removes `undefined` fields
  */
 export declare const PaymentStatusResponseSchema: z.ZodPipe<z.ZodObject<{
     acq_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
@@ -298,6 +312,8 @@ export declare const PaymentStatusResponseSchema: z.ZodPipe<z.ZodObject<{
     version?: number | undefined;
 }>>;
 /**
- * Contract of data that comes in response to a request to get payment status
+ * Final, fully normalized payment status response.
+ *
+ * Use this type in application code instead of raw API response.
  */
 export type PaymentStatusResponse = z.infer<typeof PaymentStatusResponseSchema>;

package/dist/core/types/payment-status/payment-status.response.js

@@ -7,7 +7,14 @@ const utils_1 = require("../../utils");
 const enums_1 = require("../common/enums");
 // TODO: check for optional fields on real api responses
 /**
- * Schema of data that comes in response to a request to get payment status
+ * Raw response from LiqPay `status` API.
+ *
+ * ⚠️ Important:
+ * - Field names are in `snake_case`
+ * - Types are inconsistent (`string | number | boolean`)
+ * - Dates are not parsed
+ *
+ * This schema reflects the API response **as-is**, without normalization.
  */
 exports.RawPaymentStatusResponseSchema = zod_1.z.object({
     /**
@@ -231,7 +238,14 @@ exports.RawPaymentStatusResponseSchema = zod_1.z.object({
     version: zod_1.z.number().optional(),
 });
 /**
- * Schema of data that comes in response to a request to get payment status
+ * Normalized payment status response.
+ *
+ * This schema:
+ * - converts keys to `camelCase`
+ * - normalizes primitive types
+ * - parses dates
+ * - validates enums
+ * - removes `undefined` fields
  */
 exports.PaymentStatusResponseSchema = exports.RawPaymentStatusResponseSchema.transform(raw => {
     const camelized = (0, ts_case_convert_1.objectToCamel)(raw);

package/dist/core/types/refund/refund.request.d.ts

@@ -0,0 +1,51 @@
+import z from 'zod';
+import { LiqPayVersion, RefundAction } from '../common/enums';
+/**
+ * Input data required to initiate a refund. This is the minimal payload provided by the user.
+ */
+export declare const RefundInputSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    orderId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Type of refund input.
+ */
+export type RefundInput = z.infer<typeof RefundInputSchema>;
+/**
+ * Full refund request payload (before serialization).
+ */
+export type RefundRequest = RefundInput & {
+    /**
+     * API version. The current version is `7`.
+     */
+    version: LiqPayVersion;
+    /**
+     * Public API key: The ID of the created company. Example: `i00000000`.
+     * You can retrieve this key in the store settings of your LiqPay cabinet.
+     */
+    publicKey: string;
+    /**
+     * The type of operation. For this specific request, the value must be `refund`.
+     */
+    action: RefundAction;
+};
+/**
+ * Raw refund request schema.
+ *
+ * ⚠️ Notes:
+ * - Converts object keys from camelCase → snake_case
+ * - Does NOT perform validation (assumes {@link RefundRequest} is already valid)
+ *
+ * Used right before sending data to LiqPay API.
+ */
+export declare const RawRefundRequestSchema: z.ZodPipe<z.ZodCustom<RefundRequest, RefundRequest>, z.ZodTransform<{
+    amount: number;
+    order_id: string;
+    version: LiqPayVersion;
+    public_key: string;
+    action: RefundAction;
+}, RefundRequest>>;
+/**
+ * Type of raw refund request (snake_case). Ready to be encoded and sent to LiqPay.
+ */
+export type RawRefundRequest = z.infer<typeof RawRefundRequestSchema>;

package/dist/core/types/refund/refund.request.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawRefundRequestSchema = exports.RefundInputSchema = void 0;
+const ts_case_convert_1 = require("ts-case-convert");
+const zod_1 = __importDefault(require("zod"));
+/**
+ * Input data required to initiate a refund. This is the minimal payload provided by the user.
+ */
+exports.RefundInputSchema = zod_1.default.object({
+    /**
+     * The refund amount. For example: `5`, `7.34`.
+     * The amount must be positive and cannot exceed the original transaction amount.
+     */
+    amount: zod_1.default.number().positive(),
+    /**
+     * The unique purchase ID from your store associated with the original payment.
+     * Maximum length is __255__ characters.
+     */
+    orderId: zod_1.default.string().max(255),
+});
+/**
+ * Raw refund request schema.
+ *
+ * ⚠️ Notes:
+ * - Converts object keys from camelCase → snake_case
+ * - Does NOT perform validation (assumes {@link RefundRequest} is already valid)
+ *
+ * Used right before sending data to LiqPay API.
+ */
+exports.RawRefundRequestSchema = zod_1.default
+    .custom()
+    .transform(request => {
+    const snakelized = (0, ts_case_convert_1.objectToSnake)(request);
+    return { ...snakelized };
+});

package/dist/core/types/refund/refund.response.d.ts

@@ -0,0 +1,88 @@
+import z from 'zod';
+/**
+ * Raw (non-normalized) response from LiqPay refund API.
+ *
+ * ⚠️ Notes:
+ * - Field names are in snake_case as returned by LiqPay
+ * - Some fields may have inconsistent types (e.g. string | number | boolean)
+ * - Requires transformation before safe usage
+ */
+export declare const RawRefundResponseSchema: z.ZodObject<{
+    result: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+    }>>;
+    wait_amount: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    action: z.ZodOptional<z.ZodEnum<{
+        pay: "pay";
+        hold: "hold";
+        subscribe: "subscribe";
+        paydonate: "paydonate";
+    }>>;
+    payment_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        failure: "failure";
+        reversed: "reversed";
+        success: "success";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Type of raw refund response from LiqPay.
+ */
+export type RawRefundResponse = z.infer<typeof RawRefundResponseSchema>;
+/**
+ * Normalized refund response.
+ *
+ * What this schema does:
+ * - Converts keys from snake_case → camelCase
+ * - Normalizes inconsistent field types
+ * - removes `undefined` fields
+ *
+ * Transformations:
+ * - `wait_amount` → `waitAmount` (boolean | undefined)
+ * - `payment_id` → `paymentId` (string | undefined)
+ */
+export declare const RefundResponseSchema: z.ZodPipe<z.ZodObject<{
+    result: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+    }>>;
+    wait_amount: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    action: z.ZodOptional<z.ZodEnum<{
+        pay: "pay";
+        hold: "hold";
+        subscribe: "subscribe";
+        paydonate: "paydonate";
+    }>>;
+    payment_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        failure: "failure";
+        reversed: "reversed";
+        success: "success";
+    }>>;
+}, z.core.$strip>, z.ZodTransform<Partial<{
+    /**
+     * Refund type indicator. `true` - refund from future payments, `false` - from merchant account
+     */
+    waitAmount: boolean | undefined;
+    /**
+     * Payment ID in the LiqPay system
+     */
+    paymentId: string | undefined;
+    result?: "error" | "ok" | undefined;
+    action?: "pay" | "hold" | "subscribe" | "paydonate" | undefined;
+    status?: "error" | "failure" | "reversed" | "success" | undefined;
+}>, {
+    result?: "error" | "ok" | undefined;
+    wait_amount?: string | boolean | undefined;
+    action?: "pay" | "hold" | "subscribe" | "paydonate" | undefined;
+    payment_id?: string | number | undefined;
+    status?: "error" | "failure" | "reversed" | "success" | undefined;
+}>>;
+/**
+ * Type of normalized refund response.
+ * Safe to use in application logic.
+ */
+export type RefundResponse = z.infer<typeof RefundResponseSchema>;

package/dist/core/types/refund/refund.response.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefundResponseSchema = exports.RawRefundResponseSchema = void 0;
+const ts_case_convert_1 = require("ts-case-convert");
+const zod_1 = __importDefault(require("zod"));
+const utils_1 = require("../../utils");
+const enums_1 = require("../common/enums");
+/**
+ * Raw (non-normalized) response from LiqPay refund API.
+ *
+ * ⚠️ Notes:
+ * - Field names are in snake_case as returned by LiqPay
+ * - Some fields may have inconsistent types (e.g. string | number | boolean)
+ * - Requires transformation before safe usage
+ */
+exports.RawRefundResponseSchema = zod_1.default.object({
+    /**
+     * Result of query execution: `ok`, `error`
+     */
+    result: enums_1.RequestResultSchema.optional(),
+    /**
+     * Refund type indicator. `true` - refund from future payments, `false` - from merchant account
+     */
+    wait_amount: zod_1.default.union([zod_1.default.boolean(), zod_1.default.string()]).optional(),
+    /**
+     * Operation type. Possible values:
+     * - `pay` - payment
+     * - `hold` - blocking of funds on the sender's account
+     * - `subscribe` - regular payment
+     * - `paydonate` - donation
+     */
+    action: enums_1.ActionSchema.extract([
+        'pay',
+        'hold',
+        'subscribe',
+        'paydonate',
+    ]).optional(),
+    /**
+     * Payment ID in the LiqPay system
+     */
+    payment_id: zod_1.default.union([zod_1.default.number(), zod_1.default.string()]).optional(),
+    /**
+     * Payment status. Possible values:
+     * - `error` - Unsuccessful payment. Incorrectly filled data
+     * - `failure` - Unsuccessful payment
+     * - `reversed` - Payment reversed
+     * - `success` - Successful payment
+     */
+    status: enums_1.ResolvedPaymentStatusSchema.extract([
+        'error',
+        'failure',
+        'reversed',
+        'success',
+    ]).optional(),
+});
+/**
+ * Normalized refund response.
+ *
+ * What this schema does:
+ * - Converts keys from snake_case → camelCase
+ * - Normalizes inconsistent field types
+ * - removes `undefined` fields
+ *
+ * Transformations:
+ * - `wait_amount` → `waitAmount` (boolean | undefined)
+ * - `payment_id` → `paymentId` (string | undefined)
+ */
+exports.RefundResponseSchema = exports.RawRefundResponseSchema.transform(raw => {
+    const camelized = (0, ts_case_convert_1.objectToCamel)(raw);
+    const transformed = {
+        ...camelized,
+        /**
+         * Refund type indicator. `true` - refund from future payments, `false` - from merchant account
+         */
+        waitAmount: (0, utils_1.parseBoolean)(camelized.waitAmount),
+        /**
+         * Payment ID in the LiqPay system
+         */
+        paymentId: (0, utils_1.parseString)(camelized.paymentId),
+    };
+    return (0, utils_1.removeUndefined)(transformed);
+});

package/dist/nest/services/payments.service.d.ts

@@ -4,7 +4,7 @@ import { PaymentStatusInput } from '../../core/types/payment-status';
 export declare class PaymentsService {
     private readonly client;
     constructor(client: LiqPayClient);
-    pay(payload: CheckoutInput): {
+    getCheckoutUrl(payload: CheckoutInput): {
         url: string;
         data: string;
         signature: string;
@@ -304,7 +304,7 @@ export declare class PaymentsService {
         publicKey: string;
         action: import("../..").CheckoutAction;
     };
-    getPayButton(payload: CheckoutInput, buttonText?: string, buttonColor?: string): string;
+    getCheckoutButton(payload: CheckoutInput, buttonText?: string, buttonColor?: string): string;
     getStatus(payload: PaymentStatusInput): Promise<import("../..").Result<Partial<{
         acqId: string | undefined;
         action: "data" | "pay" | "hold" | "subscribe" | "paydonate" | "auth" | "refund" | "payment_prepare" | "unsubscribe" | "subscribe_update" | "payqr" | "staticQrCreate" | "paytoken" | "paycash" | "hold_completion" | "paysplit" | "invoice_send" | "invoice_cancel" | "p2pcredit" | "p2pdebit" | "token_create" | "token_create_unique" | "token_update" | "confirm" | "mpi" | "cardverification" | "reports" | "reports_compensation" | "register" | "reports_compensation_file" | "reports_compensation_file_status" | "ticket" | "status" | "agent_shop_create" | "agent_shop_register" | "agent_shop_edit" | "agent_info_merchant" | "agent_info_user" | "regular" | undefined;

package/dist/nest/services/payments.service.js

@@ -6,7 +6,7 @@ class PaymentsService {
     constructor(client) {
         this.client = client;
     }
-    pay(payload) {
+    getCheckoutUrl(payload) {
         return this.client.payments.getCheckoutUrl(payload);
     }
     hold(payload) {
@@ -15,7 +15,7 @@ class PaymentsService {
     subscribe(payload) {
         return this.client.payments.subscribe(payload);
     }
-    getPayButton(payload, buttonText, buttonColor) {
+    getCheckoutButton(payload, buttonText, buttonColor) {
         return this.client.payments.getCheckoutButton(payload, buttonText, buttonColor);
     }
     async getStatus(payload) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "liqpay-nestjs",
 	"description": "LiqPay integration module for NestJS with support for payments, callbacks, and configuration via DI.",
-	"version": "0.3.4",
+	"version": "0.3.5",
 	"type": "commonjs",
 	"module": "dist/index.js",
 	"main": "dist/index.js",