@blocklet/payment-types 1.20.10 → 1.20.12

package/lib/checkout-session.d.ts

@@ -103,6 +103,13 @@ export declare class CheckoutSession extends Model<InferAttributes<CheckoutSessi
     nft_mint_settings?: NftMintSettings;
     nft_mint_details?: NftMintDetails;
     cross_sell_behavior?: LiteralUnion<'auto' | 'required', string>;
+    discounts?: Array<{
+        coupon?: string;
+        promotion_code?: string;
+        discount_amount?: string;
+        verification_method?: string;
+        verification_data?: Record<string, any>;
+    }>;
     fulfillment_status?: LiteralUnion<'pending' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'max_retries_exceeded' | 'return_requested' | 'sent', string>;
     vendor_info?: Array<{
         vendor_id: string;

package/lib/coupon.d.ts

@@ -1,23 +1,29 @@
 import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
 import type { LiteralUnion } from 'type-fest';
+import type { TPaymentCurrency } from './payment-currency';
 export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreationAttributes<Coupon>> {
     id: CreationOptional<string>;
     livemode: boolean;
+    locked: CreationOptional<boolean>;
     amount_off: string;
     percent_off: number;
     currency_id: string;
     duration: LiteralUnion<'forever' | 'once' | 'repeating', string>;
     duration_in_months: number;
     name: string;
+    description?: string;
     metadata: Record<string, any>;
     applies_to?: {
         products: string[];
     };
-    currency_options?: Record<string, number>;
+    currency_options?: Record<string, {
+        amount_off: string;
+    }>;
     max_redemptions?: number;
-    redeem_by?: Date;
+    redeem_by?: number;
     times_redeemed?: number;
     valid?: boolean;
+    created_via: LiteralUnion<'api' | 'dashboard' | 'portal', string>;
     created_at: CreationOptional<Date>;
     updated_at: CreationOptional<Date>;
     static readonly GENESIS_ATTRIBUTES: {
@@ -31,6 +37,10 @@ export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreation
             type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
         };
+        locked: {
+            type: DataTypes.AbstractDataTypeConstructor;
+            defaultValue: boolean;
+        };
         amount_off: {
             type: DataTypes.StringDataType;
             defaultValue: string;
@@ -42,18 +52,25 @@ export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreation
         currency_id: {
             type: DataTypes.StringDataType;
             allowNull: boolean;
+            defaultValue: string;
         };
         duration: {
             type: DataTypes.EnumDataType<"forever" | "once" | "repeating">;
+            allowNull: boolean;
         };
         duration_in_months: {
             type: DataTypes.IntegerDataTypeConstructor;
             allowNull: boolean;
+            defaultValue: number;
         };
         name: {
             type: DataTypes.StringDataType;
             allowNull: boolean;
         };
+        description: {
+            type: DataTypes.TextDataTypeConstructor;
+            allowNull: boolean;
+        };
         applies_to: {
             type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
@@ -67,7 +84,7 @@ export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreation
             allowNull: boolean;
         };
         redeem_by: {
-            type: DataTypes.DateDataTypeConstructor;
+            type: DataTypes.IntegerDataTypeConstructor;
             allowNull: boolean;
         };
         times_redeemed: {
@@ -82,6 +99,10 @@ export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreation
             type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
         };
+        created_via: {
+            type: DataTypes.EnumDataType<"api" | "dashboard" | "portal">;
+            allowNull: boolean;
+        };
         created_at: {
             type: DataTypes.DateDataTypeConstructor;
             defaultValue: DataTypes.AbstractDataTypeConstructor;
@@ -95,5 +116,19 @@ export declare class Coupon extends Model<InferAttributes<Coupon>, InferCreation
     };
     static initialize(sequelize: any): void;
     static associate(models: any): void;
+    static formatBeforeSave(coupon: Partial<TCoupon>): Partial<InferAttributes<Coupon, {
+        omit: never;
+    }>>;
+    static insert(coupon: Partial<TCoupon>): Promise<Coupon>;
+    isUsed(): Promise<boolean>;
+    getAppliedProducts(): Promise<any>;
+    /**
+     * Format currency options for storage - convert unit amounts to token amounts
+     */
+    static formatCurrencyOptions(currencyOptions: Record<string, {
+        amount_off: string;
+    }>, currencies: TPaymentCurrency[]): Record<string, {
+        amount_off: string;
+    }>;
 }
 export type TCoupon = InferAttributes<Coupon>;

package/lib/discount.d.ts

@@ -10,7 +10,10 @@ export declare class Discount extends Model<InferAttributes<Discount>, InferCrea
     invoice_id?: string;
     invoice_item_id?: string;
     start: number;
-    end: number;
+    end: number | null;
+    verification_method?: string;
+    verification_data?: Record<string, any>;
+    metadata?: Record<string, any>;
     created_at: CreationOptional<Date>;
     updated_at: CreationOptional<Date>;
     static readonly GENESIS_ATTRIBUTES: {
@@ -53,11 +56,19 @@ export declare class Discount extends Model<InferAttributes<Discount>, InferCrea
             allowNull: boolean;
         };
         start: {
-            type: DataTypes.DateDataTypeConstructor;
+            type: DataTypes.IntegerDataTypeConstructor;
             allowNull: boolean;
         };
         end: {
-            type: DataTypes.DateDataTypeConstructor;
+            type: DataTypes.IntegerDataTypeConstructor;
+            allowNull: boolean;
+        };
+        verification_method: {
+            type: DataTypes.StringDataType;
+            allowNull: boolean;
+        };
+        verification_data: {
+            type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
         };
         metadata: {

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 import { CheckoutSession, TCheckoutSession } from './checkout-session';
-import { Coupon } from './coupon';
+import { Coupon, TCoupon } from './coupon';
 import { Customer, TCustomer } from './customer';
 import { Discount } from './discount';
 import { Event, TEvent } from './event';
@@ -16,7 +16,7 @@ import { Payout, TPayout } from './payout';
 import { Price, TPrice } from './price';
 import { PricingTable, TPricingTable } from './pricing-table';
 import { Product, TProduct } from './product';
-import { PromotionCode } from './promotion-code';
+import { PromotionCode, TPromotionCode } from './promotion-code';
 import { Refund, TRefund } from './refund';
 import { SetupIntent, TSetupIntent } from './setup-intent';
 import { Subscription, TSubscription } from './subscription';
@@ -286,3 +286,12 @@ export type CreditGrantSummary = {
     remainingAmount: string;
     grantCount: number;
 };
+export type TCouponExpanded = TCoupon & {
+    object: 'coupon';
+    applied_products?: TProduct[];
+    promotion_codes?: TPromotionCode[];
+};
+export type TPromotionCodeExpanded = TPromotionCode & {
+    object: 'promotion_code';
+    coupon?: TCoupon;
+};

package/lib/promotion-code.d.ts

@@ -1,22 +1,28 @@
-import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model } from 'sequelize';
+import { CreationOptional, DataTypes, InferAttributes, InferCreationAttributes, Model, FindOptions } from 'sequelize';
+import type { LiteralUnion } from 'type-fest';
+import type { NFTConfig, Restrictions, VCConfig, VerificationType } from './types';
+import type { TPaymentCurrency } from './payment-currency';
 export declare class PromotionCode extends Model<InferAttributes<PromotionCode>, InferCreationAttributes<PromotionCode>> {
     id: CreationOptional<string>;
     livemode: boolean;
     active: boolean;
+    locked: CreationOptional<boolean>;
     code: string;
+    description?: string;
     coupon_id: string;
     max_redemptions?: number;
-    restrictions?: {
-        currency_options?: Record<string, number>;
-        first_time_transaction?: boolean;
-        minimum_amount?: number;
-        minimum_amount_currency?: string;
-    };
+    restrictions?: Restrictions;
     customer_id?: string;
     times_redeemed?: number;
-    expires_at: CreationOptional<Date>;
+    expires_at?: number;
     created_at: CreationOptional<Date>;
     updated_at: CreationOptional<Date>;
+    verification_type?: VerificationType;
+    nft_config?: NFTConfig;
+    vc_config?: VCConfig;
+    customer_dids?: string[];
+    metadata?: Record<string, any>;
+    created_via: LiteralUnion<'api' | 'dashboard' | 'portal', string>;
     static readonly GENESIS_ATTRIBUTES: {
         id: {
             type: DataTypes.StringDataType;
@@ -28,6 +34,10 @@ export declare class PromotionCode extends Model<InferAttributes<PromotionCode>,
             type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
         };
+        locked: {
+            type: DataTypes.AbstractDataTypeConstructor;
+            defaultValue: boolean;
+        };
         active: {
             type: DataTypes.AbstractDataTypeConstructor;
             defaultValue: boolean;
@@ -36,6 +46,10 @@ export declare class PromotionCode extends Model<InferAttributes<PromotionCode>,
             type: DataTypes.StringDataType;
             allowNull: boolean;
         };
+        description: {
+            type: DataTypes.TextDataTypeConstructor;
+            allowNull: boolean;
+        };
         coupon_id: {
             type: DataTypes.StringDataType;
             allowNull: boolean;
@@ -60,8 +74,11 @@ export declare class PromotionCode extends Model<InferAttributes<PromotionCode>,
             type: DataTypes.AbstractDataTypeConstructor;
             allowNull: boolean;
         };
+        created_via: {
+            type: DataTypes.EnumDataType<"api" | "dashboard" | "portal">;
+        };
         expires_at: {
-            type: DataTypes.DateDataTypeConstructor;
+            type: DataTypes.IntegerDataTypeConstructor;
             allowNull: boolean;
         };
         created_at: {
@@ -77,5 +94,46 @@ export declare class PromotionCode extends Model<InferAttributes<PromotionCode>,
     };
     static initialize(sequelize: any): void;
     static associate(models: any): void;
+    static formatBeforeSave(promotionCode: Partial<TPromotionCode>): Partial<InferAttributes<PromotionCode, {
+        omit: never;
+    }>>;
+    /**
+     * Find promotion code by multiple criteria:
+     * - id: promotion code ID
+     * - code: promotion code string
+     * - nft_address: NFT contract address (when verification_type is 'nft')
+     * - vc_role: VC role (when verification_type is 'vc')
+     * - userDid: user DID (when verification_type is 'user_restricted')
+     */
+    static findByMultipleCriteria(searchValue: string, options?: FindOptions<PromotionCode>, verificationType?: VerificationType | null): Promise<PromotionCode | null>;
+    /**
+     * Find promotion code by specific criteria type
+     */
+    static findByCode(code: string, options?: FindOptions<PromotionCode>): Promise<PromotionCode | null>;
+    static findByNftAddress(nftAddress: string, options?: FindOptions<PromotionCode>): Promise<PromotionCode | null>;
+    static findByVcRole(vcRole: string, options?: FindOptions<PromotionCode>): Promise<PromotionCode | null>;
+    static findByUserDid(userDid: string, options?: FindOptions<PromotionCode>): Promise<PromotionCode | null>;
+    /**
+     * Check if promotion code is being used
+     */
+    isUsed(): Promise<boolean>;
+    /**
+     * Check if promotion code is valid for use
+     */
+    isValid(): {
+        valid: boolean;
+        reason: string;
+    } | {
+        valid: boolean;
+        reason?: undefined;
+    };
+    /**
+     * Insert promotion code with formatting
+     */
+    static insert(promotionCode: Partial<TPromotionCode>): Promise<PromotionCode>;
+    /**
+     * Format restrictions currency options for storage - convert unit amounts to token amounts
+     */
+    static formatRestrictionsCurrencyOptions(restrictions: Restrictions | undefined, currencies: TPaymentCurrency[]): Restrictions | undefined;
 }
 export type TPromotionCode = InferAttributes<PromotionCode>;

package/lib/types.d.ts

@@ -107,7 +107,9 @@ export type SimpleCustomField = {
 };
 export type DiscountAmount = {
     amount: number;
-    discount: string;
+    discount?: string;
+    promotion_code?: string;
+    coupon?: string;
 };
 export type CustomerAddress = {
     city?: string;
@@ -465,4 +467,24 @@ export type RechargeConfig = {
         max_recharge_amount?: number;
     };
 };
+export type NFTConfig = {
+    addresses?: string[];
+    tags?: string[];
+    trusted_issuers?: string[];
+    trusted_parents?: string[];
+    min_balance?: number;
+};
+export type VCConfig = {
+    roles?: string[];
+    trusted_issuers?: string[];
+};
+export type VerificationType = 'code' | 'nft' | 'vc' | 'user_restricted';
+export type Restrictions = {
+    currency_options?: Record<string, {
+        minimum_amount: string;
+    }>;
+    first_time_transaction?: boolean;
+    minimum_amount?: string;
+    minimum_amount_currency?: string;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocklet/payment-types",
-  "version": "1.20.10",
+  "version": "1.20.12",
   "description": "Typings for Payment Kit SDK",
   "keywords": [
     "types",
@@ -48,5 +48,5 @@
     "sequelize": "^6.37.7",
     "type-fest": "^4.41.0"
   },
-  "gitHead": "1659d63120ced92167ec8681e51db96801b910ec"
+  "gitHead": "e6c432f89c2bf305efc903c0809f4a0557c07774"
 }