liqpay-nestjs 0.2.1

package/dist/core/schemas/common/enums/version.schema.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare const LiqPayVersionSchema: z.ZodLiteral<7>;

package/dist/core/schemas/common/enums/version.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiqPayVersionSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.LiqPayVersionSchema = zod_1.default.literal(7);

package/dist/core/schemas/common/fiscal-data.schema.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const LiqPayTaxRates: {
+    readonly NO_VAT: {
+        readonly letter: "А";
+        readonly name: "Без ПДВ 0%";
+        readonly type: 0;
+        readonly prc: 0;
+    };
+    readonly VAT20: {
+        readonly letter: "Б";
+        readonly name: "ПДВ 20%";
+        readonly type: 0;
+        readonly prc: 20;
+    };
+    readonly VAT7: {
+        readonly letter: "В";
+        readonly name: "ПДВ 7%";
+        readonly type: 0;
+        readonly prc: 7;
+    };
+    readonly EXCISE5: {
+        readonly letter: "Г";
+        readonly name: "АКЦИЗ 5%";
+        readonly type: 1;
+        readonly prc: 5;
+    };
+};
+export type LiqPayTaxRateKey = keyof typeof LiqPayTaxRates;
+export type LiqPayFiscalTax = (typeof LiqPayTaxRates)[LiqPayTaxRateKey];
+export declare const LiqPayFiscalTaxSchema: z.ZodObject<{
+    letter: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodNumber;
+    prc: z.ZodNumber;
+}, z.core.$strip>;
+export declare const LiqPayFiscalProductByIdSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    cost: z.ZodNumber;
+    id: z.ZodNumber;
+    price: z.ZodNumber;
+}, z.core.$strip>;
+export type LiqPayFiscalProductById = z.infer<typeof LiqPayFiscalProductByIdSchema>;
+export declare const LiqPayFiscalProductByApiSchema: z.ZodObject<{
+    amount: z.ZodNumber;
+    cost: z.ZodNumber;
+    price: z.ZodNumber;
+    categoryname: z.ZodString;
+    name: z.ZodString;
+    unitcode: z.ZodEnum<typeof import("./enums").LiqPayUnitEnum>;
+    barcode: z.ZodOptional<z.ZodString>;
+    codifier: z.ZodOptional<z.ZodString>;
+    vndcode: z.ZodOptional<z.ZodString>;
+    taxs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        letter: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodNumber;
+        prc: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type LiqPayFiscalProductByApi = z.infer<typeof LiqPayFiscalProductByApiSchema>;
+export declare const LiqPayFiscalDataSchema: z.ZodObject<{
+    items: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        amount: z.ZodNumber;
+        cost: z.ZodNumber;
+        id: z.ZodNumber;
+        price: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        amount: z.ZodNumber;
+        cost: z.ZodNumber;
+        price: z.ZodNumber;
+        categoryname: z.ZodString;
+        name: z.ZodString;
+        unitcode: z.ZodEnum<typeof import("./enums").LiqPayUnitEnum>;
+        barcode: z.ZodOptional<z.ZodString>;
+        codifier: z.ZodOptional<z.ZodString>;
+        vndcode: z.ZodOptional<z.ZodString>;
+        taxs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            letter: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodNumber;
+            prc: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>]>>>;
+    delivery_emails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type LiqPayFiscalData = z.infer<typeof LiqPayFiscalDataSchema>;

package/dist/core/schemas/common/fiscal-data.schema.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiqPayFiscalDataSchema = exports.LiqPayFiscalProductByApiSchema = exports.LiqPayFiscalProductByIdSchema = exports.LiqPayFiscalTaxSchema = exports.LiqPayTaxRates = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("./enums");
+exports.LiqPayTaxRates = {
+    NO_VAT: { letter: 'А', name: 'Без ПДВ 0%', type: 0, prc: 0 },
+    VAT20: { letter: 'Б', name: 'ПДВ 20%', type: 0, prc: 20 },
+    VAT7: { letter: 'В', name: 'ПДВ 7%', type: 0, prc: 7 },
+    EXCISE5: { letter: 'Г', name: 'АКЦИЗ 5%', type: 1, prc: 5 },
+};
+exports.LiqPayFiscalTaxSchema = zod_1.z.object({
+    letter: zod_1.z.string(),
+    name: zod_1.z.string(),
+    type: zod_1.z.number(),
+    prc: zod_1.z.number(),
+});
+exports.LiqPayFiscalProductByIdSchema = zod_1.z.object({
+    amount: zod_1.z.number(),
+    cost: zod_1.z.number(),
+    id: zod_1.z.number(),
+    price: zod_1.z.number(),
+});
+exports.LiqPayFiscalProductByApiSchema = zod_1.z.object({
+    amount: zod_1.z.number(),
+    cost: zod_1.z.number(),
+    price: zod_1.z.number(),
+    categoryname: zod_1.z.string(),
+    name: zod_1.z.string(),
+    unitcode: enums_1.LiqPayUnitSchema,
+    barcode: zod_1.z.string().optional(),
+    codifier: zod_1.z.string().optional(),
+    vndcode: zod_1.z.string().optional(),
+    taxs: zod_1.z.array(exports.LiqPayFiscalTaxSchema).optional(),
+});
+exports.LiqPayFiscalDataSchema = zod_1.z.object({
+    items: zod_1.z
+        .array(zod_1.z.union([exports.LiqPayFiscalProductByIdSchema, exports.LiqPayFiscalProductByApiSchema]))
+        .optional(),
+    delivery_emails: zod_1.z.array(zod_1.z.string()).optional(),
+});

package/dist/core/schemas/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './detail-addenda.schema';
+export * from './fiscal-data.schema';
+export * from './split-rule.schema';

package/dist/core/schemas/common/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./detail-addenda.schema"), exports);
+__exportStar(require("./fiscal-data.schema"), exports);
+__exportStar(require("./split-rule.schema"), exports);

package/dist/core/schemas/common/split-rule.schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const LiqPaySplitRuleSchema: z.ZodObject<{
+    public_key: z.ZodString;
+    amount: z.ZodNumber;
+    commission_payer: z.ZodEnum<{
+        sender: "sender";
+        receiver: "receiver";
+    }>;
+    server_url: z.ZodString;
+    rro_info: z.ZodOptional<z.ZodObject<{
+        items: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            amount: z.ZodNumber;
+            cost: z.ZodNumber;
+            id: z.ZodNumber;
+            price: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            amount: z.ZodNumber;
+            cost: z.ZodNumber;
+            price: z.ZodNumber;
+            categoryname: z.ZodString;
+            name: z.ZodString;
+            unitcode: z.ZodEnum<typeof import("./enums").LiqPayUnitEnum>;
+            barcode: z.ZodOptional<z.ZodString>;
+            codifier: z.ZodOptional<z.ZodString>;
+            vndcode: z.ZodOptional<z.ZodString>;
+            taxs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                letter: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodNumber;
+                prc: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>]>>>;
+        delivery_emails: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LiqPaySplitRule = z.infer<typeof LiqPaySplitRuleSchema>;

package/dist/core/schemas/common/split-rule.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiqPaySplitRuleSchema = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("./enums");
+const fiscal_data_schema_1 = require("./fiscal-data.schema");
+exports.LiqPaySplitRuleSchema = zod_1.z.object({
+    public_key: zod_1.z.string(),
+    amount: zod_1.z.number(),
+    commission_payer: enums_1.LiqPayCommisionPayerSchema,
+    server_url: zod_1.z.string(),
+    rro_info: fiscal_data_schema_1.LiqPayFiscalDataSchema.optional(),
+});

package/dist/core/schemas/error/error-response.schema.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+export declare const LiqPayErrorResponseSchema: z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    err_code: z.ZodEnum<{
+        5: "5";
+        limit: "limit";
+        frod: "frod";
+        decline: "decline";
+        err_auth: "err_auth";
+        err_cache: "err_cache";
+        user_not_found: "user_not_found";
+        err_sms_send: "err_sms_send";
+        err_sms_otp: "err_sms_otp";
+        shop_blocked: "shop_blocked";
+        shop_not_active: "shop_not_active";
+        invalid_signature: "invalid_signature";
+        order_id_empty: "order_id_empty";
+        err_shop_not_agent: "err_shop_not_agent";
+        err_card_def_notfound: "err_card_def_notfound";
+        err_no_card_token: "err_no_card_token";
+        err_card_liqpay_def: "err_card_liqpay_def";
+        err_card_type: "err_card_type";
+        err_card_country: "err_card_country";
+        err_limit_amount: "err_limit_amount";
+        err_payment_amount_limit: "err_payment_amount_limit";
+        amount_limit: "amount_limit";
+        payment_err_sender_card: "payment_err_sender_card";
+        payment_processing: "payment_processing";
+        err_payment_discount: "err_payment_discount";
+        err_wallet: "err_wallet";
+        err_get_verify_code: "err_get_verify_code";
+        err_verify_code: "err_verify_code";
+        wait_info: "wait_info";
+        err_path: "err_path";
+        err_payment_cash_acq: "err_payment_cash_acq";
+        err_split_amount: "err_split_amount";
+        err_card_receiver_def: "err_card_receiver_def";
+        payment_err_status: "payment_err_status";
+        public_key_not_found: "public_key_not_found";
+        payment_not_found: "payment_not_found";
+        payment_not_subscribed: "payment_not_subscribed";
+        wrong_amount_currency: "wrong_amount_currency";
+        err_amount_hold: "err_amount_hold";
+        err_access: "err_access";
+        order_id_duplicate: "order_id_duplicate";
+        err_blocked: "err_blocked";
+        err_empty: "err_empty";
+        err_empty_phone: "err_empty_phone";
+        err_missing: "err_missing";
+        err_wrong: "err_wrong";
+        err_wrong_currency: "err_wrong_currency";
+        err_phone: "err_phone";
+        err_card: "err_card";
+        err_card_bin: "err_card_bin";
+        err_terminal_notfound: "err_terminal_notfound";
+        err_commission_notfound: "err_commission_notfound";
+        err_payment_create: "err_payment_create";
+        err_mpi: "err_mpi";
+        err_currency_is_not_allowed: "err_currency_is_not_allowed";
+        err_look: "err_look";
+        err_mods_empty: "err_mods_empty";
+        payment_err_type: "payment_err_type";
+        err_payment_currency: "err_payment_currency";
+        err_payment_exchangerates: "err_payment_exchangerates";
+        err_signature: "err_signature";
+        err_api_action: "err_api_action";
+        err_api_callback: "err_api_callback";
+        err_api_ip: "err_api_ip";
+        expired_phone: "expired_phone";
+        expired_3ds: "expired_3ds";
+        expired_otp: "expired_otp";
+        expired_cvv: "expired_cvv";
+        expired_p24: "expired_p24";
+        expired_sender: "expired_sender";
+        expired_pin: "expired_pin";
+        expired_ivr: "expired_ivr";
+        expired_captcha: "expired_captcha";
+        expired_password: "expired_password";
+        expired_senderapp: "expired_senderapp";
+        expired_prepared: "expired_prepared";
+        expired_mp: "expired_mp";
+        expired_qr: "expired_qr";
+        90: "90";
+        101: "101";
+        102: "102";
+        103: "103";
+        104: "104";
+        105: "105";
+        106: "106";
+        107: "107";
+        108: "108";
+        109: "109";
+        110: "110";
+        111: "111";
+        112: "112";
+        113: "113";
+        114: "114";
+        115: "115";
+        2903: "2903";
+        2915: "2915";
+        3914: "3914";
+        9851: "9851";
+        9852: "9852";
+        9854: "9854";
+        9855: "9855";
+        9857: "9857";
+        9859: "9859";
+        9860: "9860";
+        9861: "9861";
+        9863: "9863";
+        9867: "9867";
+        9868: "9868";
+        9872: "9872";
+        9882: "9882";
+        9886: "9886";
+        9961: "9961";
+        9989: "9989";
+    }>;
+    err_description: z.ZodString;
+}, z.core.$strip>;
+export type LiqPayErrorResponse = z.infer<typeof LiqPayErrorResponseSchema>;

package/dist/core/schemas/error/error-response.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiqPayErrorResponseSchema = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("../common/enums");
+exports.LiqPayErrorResponseSchema = zod_1.z.object({
+    status: zod_1.z.literal('error'),
+    err_code: enums_1.LiqPayErrorCodeSchema,
+    err_description: zod_1.z.string(),
+});

package/dist/core/schemas/error/error.type.d.ts

@@ -0,0 +1,6 @@
+import { LiqPayErrorCode } from '../common/enums';
+export type InternalErrorCode = LiqPayErrorCode | 'decode_error' | 'validation_error' | 'invalid_response' | 'http_error';
+export type LiqPayError = {
+    code: LiqPayErrorCode | InternalErrorCode;
+    description: string;
+};

package/dist/core/schemas/error/error.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/schemas/error/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../common/enums/error-code.schema';
+export * from './error-response.schema';
+export * from './error.type';

package/dist/core/schemas/error/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("../common/enums/error-code.schema"), exports);
+__exportStar(require("./error-response.schema"), exports);
+__exportStar(require("./error.type"), exports);

package/dist/core/schemas/payment-status/index.d.ts

@@ -0,0 +1,2 @@
+export * from './payment-status-request.schema';
+export * from './payment-status-response.schema';

package/dist/core/schemas/payment-status/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./payment-status-request.schema"), exports);
+__exportStar(require("./payment-status-response.schema"), exports);

package/dist/core/schemas/payment-status/payment-status-request.schema.d.ts

@@ -0,0 +1,43 @@
+import z from 'zod';
+export declare const LiqPayPaymentStatusRequestSchema: z.ZodObject<{
+    version: z.ZodLiteral<7>;
+    publicKey: z.ZodOptional<z.ZodString>;
+    action: z.ZodEnum<{
+        pay: "pay";
+        hold: "hold";
+        paysplit: "paysplit";
+        subscribe: "subscribe";
+        paydonate: "paydonate";
+        auth: "auth";
+        regular: "regular";
+        status: "status";
+    }>;
+    orderId: z.ZodString;
+}, z.core.$strip>;
+export type LiqPayPaymentStatusRequest = z.infer<typeof LiqPayPaymentStatusRequestSchema>;
+export declare const LiqPayRawPaymentStatusRequestSchema: z.ZodPipe<z.ZodObject<{
+    version: z.ZodLiteral<7>;
+    publicKey: z.ZodOptional<z.ZodString>;
+    action: z.ZodEnum<{
+        pay: "pay";
+        hold: "hold";
+        paysplit: "paysplit";
+        subscribe: "subscribe";
+        paydonate: "paydonate";
+        auth: "auth";
+        regular: "regular";
+        status: "status";
+    }>;
+    orderId: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<{
+    version: number;
+    action: string;
+    order_id: string;
+    public_key?: string | undefined;
+}, {
+    version: 7;
+    action: "pay" | "hold" | "paysplit" | "subscribe" | "paydonate" | "auth" | "regular" | "status";
+    orderId: string;
+    publicKey?: string | undefined;
+}>>;
+export type LiqPayRawPaymentStatusRequest = z.infer<typeof LiqPayRawPaymentStatusRequestSchema>;

package/dist/core/schemas/payment-status/payment-status-request.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiqPayRawPaymentStatusRequestSchema = exports.LiqPayPaymentStatusRequestSchema = void 0;
+const ts_case_convert_1 = require("ts-case-convert");
+const zod_1 = __importDefault(require("zod"));
+const enums_1 = require("../common/enums");
+exports.LiqPayPaymentStatusRequestSchema = zod_1.default.object({
+    version: enums_1.LiqPayVersionSchema,
+    publicKey: zod_1.default.string().optional(),
+    action: enums_1.LiqPayActionSchema,
+    orderId: zod_1.default.string().max(255),
+});
+exports.LiqPayRawPaymentStatusRequestSchema = exports.LiqPayPaymentStatusRequestSchema.transform(typed => {
+    const snakelized = (0, ts_case_convert_1.objectToSnake)(typed);
+    return {
+        ...snakelized,
+        version: Number(snakelized.version),
+        action: String(snakelized.action),
+    };
+});