@blocklet/payment-js 1.20.15 → 1.20.17

package/README.md

@@ -1,6 +1,6 @@
 # PaymentKit Node.js SDK
 
-A Node.js SDK for the PaymentKit API. This package allows you to manage resources in PaymentKit including customers, subscriptions, products, prices, payments, checkout sessions, usage records, webhooks, and **credit-based billing with meters and credit grants**.
+A Node.js SDK for the PaymentKit API. This package allows you to manage resources in PaymentKit including customers, subscriptions, products, prices, payments, checkout sessions, usage records, webhooks, **credit-based billing with meters and credit grants**, **discount management with coupons and promotion codes**, and **comprehensive invoice operations**.
 
 ## Related Links
 
@@ -164,6 +164,85 @@ const transactions = await payment.creditTransactions.list({
 });
 ```
 
+### Managing Coupons and Promotion Codes
+
+```js
+// Create a coupon with promotion codes
+const result = await payment.coupons.create({
+  name: 'New User Discount',
+  percent_off: 20,
+  duration: 'once',
+  max_redemptions: 1000,
+  promotion_codes: [
+    {
+      code: 'WELCOME20',
+      description: 'Welcome discount for new users',
+      max_redemptions: 100,
+      expires_at: Math.floor(Date.now() / 1000) + (30 * 24 * 60 * 60) // 30 days
+    }
+  ]
+});
+
+// Create standalone promotion code
+const promotionCode = await payment.promotionCodes.create({
+  coupon_id: 'coupon_xxx',
+  description: 'Save 15% on your purchase',
+  verification_type: 'code',
+  max_redemptions: 500
+});
+
+// Get promotion code by code
+const promoByCode = await payment.promotionCodes.byCode('WELCOME20');
+
+// Check coupon usage
+const { used } = await payment.coupons.used('coupon_xxx');
+
+// Get redemptions data
+const redemptions = await payment.coupons.redemptions('coupon_xxx', {
+  type: 'customer',
+  page: 1,
+  pageSize: 20
+});
+```
+
+### Managing Invoices
+
+```js
+// Retrieve invoice with discount details
+const invoice = await payment.invoices.retrieve('inv_xxx');
+console.log(invoice.discountDetails); // Applied discounts
+console.log(invoice.relatedCreditGrants); // Related credit grants
+
+// List invoices with filters
+const invoices = await payment.invoices.list({
+  customer_id: 'cus_xxx',
+  status: 'paid,open',
+  ignore_zero: true,
+  include_staking: false,
+  page: 1,
+  pageSize: 20
+});
+
+// Search invoices
+const searchResults = await payment.invoices.search({
+  query: 'invoice number or customer',
+  page: 1,
+  pageSize: 10
+});
+
+// Update invoice metadata
+const updatedInvoice = await payment.invoices.update('inv_xxx', {
+  metadata: { notes: 'Updated invoice' }
+});
+
+// Void an invoice
+const voidedInvoice = await payment.invoices.void('inv_xxx');
+
+// Handle staking operations
+const stakeInfo = await payment.invoices.getReturnStake('inv_stake_xxx');
+const returnResult = await payment.invoices.returnStake('inv_stake_xxx');
+```
+
 ### Handling Refunds
 
 ```js
@@ -182,12 +261,17 @@ const webhook = await payment.webhookEndpoints.create({
   enabled_events: [
     'checkout.session.completed',
     'checkout.session.nft_minted',
+    'checkout.session.expired',
     'customer.subscription.created',
     'customer.subscription.deleted',
     'customer.subscription.paused',
     'customer.subscription.updated',
     'customer.subscription.started',
     'customer.subscription.renewed',
+    'invoice.created',
+    'invoice.paid',
+    'invoice.payment_failed',
+    'invoice.voided',
     'payment_intent.created',
     'payment_intent.succeeded'
   ]
@@ -296,6 +380,37 @@ const webhook = await payment.webhookEndpoints.create({
 - `payment.creditTransactions.list(params)` - List credit transactions
 - `payment.creditTransactions.summary(params)` - Get usage and credit summary
 
+### Coupons & Promotion Codes
+
+#### Coupons
+- `payment.coupons.create(data)` - Create coupon with optional promotion codes
+- `payment.coupons.retrieve(id)` - Get coupon details with related data
+- `payment.coupons.update(id, data)` - Update coupon information
+- `payment.coupons.list(params)` - List coupons with filtering
+- `payment.coupons.del(id)` - Delete coupon
+- `payment.coupons.used(id)` - Check if coupon is being used
+- `payment.coupons.redemptions(id, params)` - Get coupon redemption details
+
+#### Promotion Codes
+- `payment.promotionCodes.create(data)` - Create promotion code
+- `payment.promotionCodes.retrieve(id)` - Get promotion code details
+- `payment.promotionCodes.update(id, data)` - Update promotion code
+- `payment.promotionCodes.list(params)` - List promotion codes
+- `payment.promotionCodes.archive(id)` - Archive promotion code
+- `payment.promotionCodes.del(id)` - Delete promotion code
+- `payment.promotionCodes.used(id)` - Check if promotion code is being used
+- `payment.promotionCodes.byCode(code)` - Get promotion code by code string
+- `payment.promotionCodes.redemptions(id, params)` - Get promotion code redemptions
+
+### Invoices
+- `payment.invoices.retrieve(id)` - Get invoice with discount and related data
+- `payment.invoices.update(id, data)` - Update invoice metadata
+- `payment.invoices.list(params)` - List invoices with comprehensive filtering
+- `payment.invoices.search(params)` - Search invoices by query
+- `payment.invoices.getReturnStake(id)` - Get stake return information
+- `payment.invoices.returnStake(id)` - Execute stake return operation
+- `payment.invoices.void(id)` - Void an invoice
+
 ### Webhooks
 - `payment.webhookEndpoints.create(data)`
 - `payment.webhookEndpoints.retrieve(id)`
@@ -322,6 +437,46 @@ The PaymentKit SDK supports credit-based billing, allowing you to:
 - `count`: Count number of events
 - `last`: Use the last reported value
 
+## Discount Management
+
+The PaymentKit SDK provides comprehensive discount management through coupons and promotion codes:
+
+### Coupons
+- **Amount-based or Percentage Discounts**: Create fixed amount or percentage-based discounts
+- **Duration Control**: Set discounts for 'once', 'forever', or 'repeating' billing cycles
+- **Usage Limits**: Control maximum redemptions and expiration dates
+- **Multi-Currency Support**: Configure different discount amounts per currency
+- **Product Targeting**: Apply discounts to specific products
+
+### Promotion Codes
+- **Access Control**: Create codes for public use or restrict to specific customers
+- **Verification Types**: Support code-based, NFT-based, VC-based, or user-restricted verification
+- **Usage Tracking**: Monitor redemption statistics and usage patterns
+- **Flexible Restrictions**: Set minimum purchase amounts and other conditions
+
+### Key Features
+- **Automatic Application**: Discounts are automatically calculated during checkout
+- **Usage Rollback**: Failed payments don't consume discount usage quotas
+- **Analytics**: Track redemption patterns and discount effectiveness
+- **Audit Trail**: Complete history of discount applications and modifications
+
+## Invoice Management
+
+The PaymentKit SDK offers comprehensive invoice operations:
+
+### Core Features
+- **Rich Details**: Retrieve invoices with discount details, payment information, and related data
+- **Advanced Filtering**: Filter by customer, status, currency, subscription, and custom metadata
+- **Search Capability**: Full-text search across invoice data
+- **Staking Operations**: Handle stake deposits and returns for subscription-based services
+- **Status Management**: Void invoices and handle payment state transitions
+
+### Special Invoice Types
+- **Regular Billing**: Standard subscription and one-time payment invoices
+- **Staking Invoices**: Handle deposits and collateral for services
+- **Recharge Invoices**: Credit top-ups and account funding
+- **Overdraft Protection**: Automatic coverage for account shortfalls
+
 ## Subscription Status
 
 A subscription can have the following statuses:

package/lib/index.d.ts

@@ -427,6 +427,104 @@ declare const _default: {
             message: string;
         }>;
     };
+    promotionCodes: {
+        create: (data: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+            omit: never;
+        }>>, params?: never) => Promise<import("@blocklet/payment-types").TPromotionCodeExpanded>;
+        retrieve: (_params: string, data?: never) => Promise<import("@blocklet/payment-types").TPromotionCodeExpanded>;
+        update: (_params: string, data?: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+            omit: never;
+        }>>) => Promise<import("@blocklet/payment-types").TPromotionCodeExpanded>;
+        list: (_params: import("@blocklet/payment-types").Pagination<{
+            coupon_id?: string;
+            active?: boolean;
+        }>, data?: never) => Promise<import("@blocklet/payment-types").Paginated<import("@blocklet/payment-types").TPromotionCodeExpanded>>;
+        archive: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+            omit: never;
+        }>>;
+        del: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+            omit: never;
+        }>>;
+        used: (_params: string, data?: never) => Promise<{
+            used: boolean;
+        }>;
+        byCode: (_params: string, data?: never) => Promise<import("@blocklet/payment-types").TPromotionCodeExpanded>;
+        redemptions: (_params: {
+            type?: "customer" | "subscription";
+        } & {
+            page?: number;
+            pageSize?: number;
+            limit?: number;
+            starting_after?: string;
+            ending_before?: string;
+            order?: import("@blocklet/payment-types").OrderInput;
+        } & {
+            id: string;
+        }, data?: never) => Promise<import("./resources/promotion-code").RedemptionData>;
+    };
+    coupons: {
+        create: (data: import("./resources/coupon").CouponCreateInput, params?: never) => Promise<import("./resources/coupon").CouponCreateResponse>;
+        retrieve: (_params: string, data?: never) => Promise<import("@blocklet/payment-types").TCouponExpanded>;
+        update: (_params: string, data?: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+            omit: never;
+        }>>) => Promise<import("@blocklet/payment-types").TCouponExpanded>;
+        list: (_params: import("@blocklet/payment-types").Pagination<{
+            [key: `metadata.${string}`]: string;
+            valid?: boolean;
+            name?: string;
+        }>, data?: never) => Promise<import("@blocklet/payment-types").Paginated<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+            omit: never;
+        }>>>;
+        del: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+            omit: never;
+        }>>;
+        used: (_params: string, data?: never) => Promise<{
+            used: boolean;
+        }>;
+        redemptions: (_params: {
+            type?: "customer" | "subscription";
+        } & {
+            page?: number;
+            pageSize?: number;
+            limit?: number;
+            starting_after?: string;
+            ending_before?: string;
+            order?: import("@blocklet/payment-types").OrderInput;
+        } & {
+            id: string;
+        }, data?: never) => Promise<import("./resources/coupon").RedemptionData>;
+    };
+    invoices: {
+        retrieve: (_params: string, data?: never) => Promise<import("./resources/invoice").InvoiceWithDiscount>;
+        update: (_params: string, data?: {
+            metadata?: Record<string, any>;
+        }) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Invoice, {
+            omit: never;
+        }>>;
+        list: (_params: import("@blocklet/payment-types").Pagination<{
+            [key: `metadata.${string}`]: string;
+            status?: string;
+            customer_id?: string;
+            customer_did?: string;
+            subscription_id?: string;
+            currency_id?: string;
+            ignore_zero?: boolean;
+            include_staking?: boolean;
+            include_return_staking?: boolean;
+            include_overdraft_protection?: boolean;
+            include_recovered_from?: boolean;
+        }>, data?: never) => Promise<import("@blocklet/payment-types").Paginated<import("@blocklet/payment-types").TInvoiceExpanded>>;
+        search: (_params: any, data?: never) => Promise<import("@blocklet/payment-types").Paginated<import("@blocklet/payment-types").TInvoiceExpanded>>;
+        getReturnStake: (_params: string, data?: never) => Promise<any>;
+        returnStake: (_params: string, data?: never) => Promise<{
+            success: boolean;
+            subscriptionId?: string;
+            error?: string;
+        }>;
+        void: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Invoice, {
+            omit: never;
+        }>>;
+    };
     isPaymentRunning: () => boolean;
     ensureStart: typeof ensureStart;
 };

package/lib/index.js

@@ -35,6 +35,9 @@ const meter_1 = __importDefault(require("./resources/meter"));
 const meter_event_1 = __importDefault(require("./resources/meter-event"));
 const credit_grant_1 = __importDefault(require("./resources/credit-grant"));
 const credit_transaction_1 = __importDefault(require("./resources/credit-transaction"));
+const promotion_code_1 = __importDefault(require("./resources/promotion-code"));
+const coupon_1 = __importDefault(require("./resources/coupon"));
+const invoice_1 = __importDefault(require("./resources/invoice"));
 // auto detect livemode
 if (process.env.PAYMENT_LIVEMODE) {
     resource_1.environments.setLivemode(process.env.PAYMENT_LIVEMODE === 'true');
@@ -66,6 +69,9 @@ exports.default = {
     environments: resource_1.environments,
     refunds: refund_1.default,
     settings: setting_1.default,
+    promotionCodes: promotion_code_1.default,
+    coupons: coupon_1.default,
+    invoices: invoice_1.default,
     isPaymentRunning: resource_1.isPaymentRunning,
     ensureStart: resource_1.ensureStart,
 };

package/lib/resources/coupon.d.ts

@@ -0,0 +1,59 @@
+import type { TCoupon, TPromotionCode, Paginated, Pagination, TCouponExpanded, TSubscriptionExpanded, TPromotionCodeExpanded, TCustomerExpanded } from '@blocklet/payment-types';
+export type CouponCreateInput = Partial<TCoupon> & {
+    promotion_codes?: Partial<TPromotionCode>[];
+};
+export type CouponCreateResponse = {
+    coupon: TCoupon;
+    promotion_codes: TPromotionCode[];
+};
+export type RedemptionData = {
+    count: number;
+    subscriptions: TSubscriptionExpanded & {
+        discount_info: {
+            discount_id: string;
+            coupon_info?: TCouponExpanded;
+            promotion_code_info?: TPromotionCodeExpanded;
+        };
+    }[];
+    customers: TCustomerExpanded & {
+        coupon_usage_stats: Record<string, any>;
+        discount_records: Array<any>;
+    }[];
+    paging: {
+        page: number;
+        pageSize: number;
+    };
+};
+declare const _default: {
+    create: (data: CouponCreateInput, params?: never) => Promise<CouponCreateResponse>;
+    retrieve: (_params: string, data?: never) => Promise<TCouponExpanded>;
+    update: (_params: string, data?: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+        omit: never;
+    }>>) => Promise<TCouponExpanded>;
+    list: (_params: Pagination<{
+        [key: `metadata.${string}`]: string;
+        valid?: boolean;
+        name?: string;
+    }>, data?: never) => Promise<Paginated<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+        omit: never;
+    }>>>;
+    del: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Coupon, {
+        omit: never;
+    }>>;
+    used: (_params: string, data?: never) => Promise<{
+        used: boolean;
+    }>;
+    redemptions: (_params: {
+        type?: "customer" | "subscription";
+    } & {
+        page?: number;
+        pageSize?: number;
+        limit?: number;
+        starting_after?: string;
+        ending_before?: string;
+        order?: import("@blocklet/payment-types").OrderInput;
+    } & {
+        id: string;
+    }, data?: never) => Promise<RedemptionData>;
+};
+export default _default;

package/lib/resources/coupon.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+exports.default = {
+    create: (0, resource_1.createResourceCreateMethod)({
+        method: 'POST',
+        path: '/api/coupons',
+    }),
+    retrieve: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/coupons/{id}',
+    }),
+    update: (0, resource_1.createResourceMethod)({
+        method: 'PUT',
+        path: '/api/coupons/{id}',
+    }),
+    list: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/coupons',
+    }),
+    del: (0, resource_1.createResourceMethod)({
+        method: 'DELETE',
+        path: '/api/coupons/{id}',
+    }),
+    used: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/coupons/{id}/used',
+    }),
+    redemptions: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/coupons/{id}/redemptions',
+    }),
+};

package/lib/resources/invoice.d.ts

@@ -0,0 +1,43 @@
+import type { TInvoice, TInvoiceExpanded, Paginated, Pagination, TCouponExpanded, TPromotionCodeExpanded, TPaymentLink, TCheckoutSession, TCreditGrantExpanded } from '@blocklet/payment-types';
+export type InvoiceWithDiscount = TInvoiceExpanded & {
+    discountDetails?: Array<{
+        coupon?: TCouponExpanded;
+        promotionCode?: TPromotionCodeExpanded;
+    }>;
+    relatedInvoice?: Partial<TInvoice>;
+    relatedCreditGrants?: TCreditGrantExpanded[];
+    paymentLink?: TPaymentLink;
+    checkoutSession?: TCheckoutSession;
+};
+declare const _default: {
+    retrieve: (_params: string, data?: never) => Promise<InvoiceWithDiscount>;
+    update: (_params: string, data?: {
+        metadata?: Record<string, any>;
+    }) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Invoice, {
+        omit: never;
+    }>>;
+    list: (_params: Pagination<{
+        [key: `metadata.${string}`]: string;
+        status?: string;
+        customer_id?: string;
+        customer_did?: string;
+        subscription_id?: string;
+        currency_id?: string;
+        ignore_zero?: boolean;
+        include_staking?: boolean;
+        include_return_staking?: boolean;
+        include_overdraft_protection?: boolean;
+        include_recovered_from?: boolean;
+    }>, data?: never) => Promise<Paginated<TInvoiceExpanded>>;
+    search: (_params: any, data?: never) => Promise<Paginated<TInvoiceExpanded>>;
+    getReturnStake: (_params: string, data?: never) => Promise<any>;
+    returnStake: (_params: string, data?: never) => Promise<{
+        success: boolean;
+        subscriptionId?: string;
+        error?: string;
+    }>;
+    void: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").Invoice, {
+        omit: never;
+    }>>;
+};
+export default _default;

package/lib/resources/invoice.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+exports.default = {
+    retrieve: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/invoices/{id}',
+    }),
+    update: (0, resource_1.createResourceMethod)({
+        method: 'PUT',
+        path: '/api/invoices/{id}',
+    }),
+    list: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/invoices',
+    }),
+    search: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/invoices/search',
+    }),
+    getReturnStake: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/invoices/{id}/return-stake',
+    }),
+    returnStake: (0, resource_1.createResourceMethod)({
+        method: 'POST',
+        path: '/api/invoices/{id}/return-stake',
+    }),
+    void: (0, resource_1.createResourceMethod)({
+        method: 'POST',
+        path: '/api/invoices/{id}/void',
+    }),
+};

package/lib/resources/promotion-code.d.ts

@@ -0,0 +1,55 @@
+import type { TPromotionCodeExpanded, Paginated, Pagination, TCustomerExpanded, TCouponExpanded, TSubscriptionExpanded } from '@blocklet/payment-types';
+export type RedemptionData = {
+    count: number;
+    subscriptions: TSubscriptionExpanded & {
+        discount_info: {
+            discount_id: string;
+            coupon_info?: TCouponExpanded;
+            promotion_code_info?: TPromotionCodeExpanded;
+        };
+    }[];
+    customers: TCustomerExpanded & {
+        coupon_usage_stats: Record<string, any>;
+        discount_records: Array<any>;
+    }[];
+    paging: {
+        page: number;
+        pageSize: number;
+    };
+};
+declare const _default: {
+    create: (data: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+        omit: never;
+    }>>, params?: never) => Promise<TPromotionCodeExpanded>;
+    retrieve: (_params: string, data?: never) => Promise<TPromotionCodeExpanded>;
+    update: (_params: string, data?: Partial<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+        omit: never;
+    }>>) => Promise<TPromotionCodeExpanded>;
+    list: (_params: Pagination<{
+        coupon_id?: string;
+        active?: boolean;
+    }>, data?: never) => Promise<Paginated<TPromotionCodeExpanded>>;
+    archive: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+        omit: never;
+    }>>;
+    del: (_params: string, data?: never) => Promise<import("sequelize").InferAttributes<import("@blocklet/payment-types").PromotionCode, {
+        omit: never;
+    }>>;
+    used: (_params: string, data?: never) => Promise<{
+        used: boolean;
+    }>;
+    byCode: (_params: string, data?: never) => Promise<TPromotionCodeExpanded>;
+    redemptions: (_params: {
+        type?: "customer" | "subscription";
+    } & {
+        page?: number;
+        pageSize?: number;
+        limit?: number;
+        starting_after?: string;
+        ending_before?: string;
+        order?: import("@blocklet/payment-types").OrderInput;
+    } & {
+        id: string;
+    }, data?: never) => Promise<RedemptionData>;
+};
+export default _default;

package/lib/resources/promotion-code.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+exports.default = {
+    create: (0, resource_1.createResourceCreateMethod)({
+        method: 'POST',
+        path: '/api/promotion-codes',
+    }),
+    retrieve: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/promotion-codes/{id}',
+    }),
+    update: (0, resource_1.createResourceMethod)({
+        method: 'PUT',
+        path: '/api/promotion-codes/{id}',
+    }),
+    list: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/promotion-codes',
+    }),
+    archive: (0, resource_1.createResourceMethod)({
+        method: 'PUT',
+        path: '/api/promotion-codes/{id}/archive',
+    }),
+    del: (0, resource_1.createResourceMethod)({
+        method: 'DELETE',
+        path: '/api/promotion-codes/{id}',
+    }),
+    used: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/promotion-codes/{id}/used',
+    }),
+    byCode: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/promotion-codes/by-code/{code}',
+    }),
+    redemptions: (0, resource_1.createResourceMethod)({
+        method: 'GET',
+        path: '/api/promotion-codes/{id}/redemptions',
+    }),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocklet/payment-js",
-  "version": "1.20.15",
+  "version": "1.20.17",
   "description": "Node.js client for Payment Kit",
   "keywords": [
     "types",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@blocklet/constant": "^1.16.52-beta-20250912-112002-e3499e9c",
-    "@blocklet/payment-types": "1.20.15",
+    "@blocklet/payment-types": "1.20.17",
     "@blocklet/sdk": "^1.16.52-beta-20250912-112002-e3499e9c"
   },
   "importSort": {
@@ -64,5 +64,5 @@
     "type-fest": "^4.41.0",
     "typescript": "5.5.4"
   },
-  "gitHead": "d205c3b1ec7d2b819e375ed2eb8b70c9d48f0bcb"
+  "gitHead": "20e9d7519327cb4df0c93375ff85783303fc99d6"
 }