@voucherify/sdk 2.9.3 → 2.9.4

package/dist/types/Stackable.d.ts

@@ -0,0 +1,106 @@
+import { RewardRedemptionParams } from './Rewards.js';
+import { GiftRedemptionParams } from './Gift.js';
+import { OrdersCreateResponse } from './Orders.js';
+import { ApplicableToResultList } from './ApplicableTo.js';
+import { DiscountVouchersTypes, DiscountVouchersEffectTypes, DiscountUnitVouchersEffectTypes } from './DiscountVoucher.js';
+import { SimpleSku, SimpleProduct } from './Products.js';
+import { LoyaltyPointsTransfer } from './Loyalties.js';
+import { ValidationError } from './ValidationError.js';
+import { Category } from './Categories.js';
+import './Customers.js';
+import './ValidationRules.js';
+import './Vouchers.js';
+
+type ExpandOption = 'order' | 'redeemable' | 'redemption';
+interface StackableOptions {
+    expand: ExpandOption[];
+}
+type StackableRedeemableObject = 'promotion_stack' | 'promotion_tier' | 'voucher';
+interface StackableRedeemableParams {
+    object: StackableRedeemableObject;
+    id: string;
+    reward?: RewardRedemptionParams;
+    gift?: GiftRedemptionParams;
+}
+type StackableRedeemableResponseStatus = 'APPLICABLE' | 'INAPPLICABLE' | 'SKIPPED';
+interface StackableRedeemableResultDiscountUnit {
+    effect: DiscountUnitVouchersEffectTypes;
+    unit_off: number;
+    unit_type: string;
+    sku?: SimpleSku;
+    product?: SimpleProduct;
+}
+interface StackableRedeemableResultDiscount {
+    type: DiscountVouchersTypes;
+    effect: DiscountVouchersEffectTypes;
+    amount_off?: number;
+    amount_off_formula?: string;
+    percent_off?: number;
+    percent_off_formula?: string;
+    amount_limit?: number;
+    fixed_amount?: number;
+    fixed_amount_formula?: string;
+    unit_off?: number;
+    unit_off_formula?: string;
+    unit_type?: string;
+    sku?: SimpleSku;
+    product?: SimpleProduct;
+    units?: StackableRedeemableResultDiscountUnit[];
+}
+interface StackableRedeemableResultGift {
+    credits?: number;
+}
+interface StackableRedeemableResultLoyaltyCard {
+    points?: number;
+    transfers?: LoyaltyPointsTransfer[];
+}
+interface StackableRedeemableResultResponse {
+    discount?: StackableRedeemableResultDiscount;
+    gift?: StackableRedeemableResultGift;
+    loyalty_card?: StackableRedeemableResultLoyaltyCard;
+    error?: ValidationError;
+    details?: {
+        key?: string;
+        message?: string;
+    };
+}
+interface StackableRedeemableResponse {
+    status: StackableRedeemableResponseStatus;
+    id: string;
+    object: StackableRedeemableObject;
+    order?: OrdersCreateResponse;
+    applicable_to?: ApplicableToResultList;
+    inapplicable_to?: ApplicableToResultList;
+    result?: StackableRedeemableResultResponse;
+    metadata?: Record<string, any>;
+    categories?: Category[];
+}
+type StackableRedeemableInapplicableResponse = {
+    status: 'INAPPLICABLE';
+    id: string;
+    object: 'voucher' | 'promotion_tier';
+    result: {
+        error?: ValidationError;
+        details?: {
+            key?: string;
+            message?: string;
+        };
+    };
+    metadata?: Record<string, unknown>;
+    categories?: Category[];
+};
+type StackableRedeemableSkippedResponse = {
+    status: 'SKIPPED';
+    id: string;
+    object: 'voucher' | 'promotion_tier';
+    result: {
+        details?: {
+            key?: string;
+            message?: string;
+        };
+    };
+    metadata?: Record<string, unknown>;
+    categories?: Category[];
+};
+
+export type { StackableOptions, StackableRedeemableInapplicableResponse, StackableRedeemableObject, StackableRedeemableParams, StackableRedeemableResponse, StackableRedeemableResponseStatus, StackableRedeemableResultDiscount, StackableRedeemableResultDiscountUnit, StackableRedeemableResultGift, StackableRedeemableResultLoyaltyCard, StackableRedeemableResultResponse, StackableRedeemableSkippedResponse };

package/dist/types/UtilityTypes.d.ts

@@ -0,0 +1,5 @@
+type WithRequiredProperty<Type, Key extends keyof Type> = Type & {
+    [Property in Key]-?: Type[Property];
+};
+
+export type { WithRequiredProperty };

package/dist/types/ValidateSession.d.ts

@@ -0,0 +1,19 @@
+type ValidationSessionType = 'LOCK';
+type ValidationSessionTTLUnit = 'DAYS' | 'HOURS' | 'MICROSECONDS' | 'MILLISECONDS' | 'MINUTES' | 'NANOSECONDS' | 'SECONDS';
+interface ValidationSessionParams {
+    key?: string;
+    type?: ValidationSessionType;
+    ttl?: number;
+    ttl_unit?: ValidationSessionTTLUnit;
+}
+interface ValidationSessionResponse {
+    key: string;
+    type: ValidationSessionType;
+    ttl: number;
+    ttl_unit: ValidationSessionTTLUnit;
+}
+interface ValidationSessionReleaseParams {
+    key: string;
+}
+
+export type { ValidationSessionParams, ValidationSessionReleaseParams, ValidationSessionResponse, ValidationSessionTTLUnit, ValidationSessionType };

package/dist/types/ValidationError.d.ts

@@ -0,0 +1,9 @@
+interface ValidationError {
+    code?: number;
+    key?: string;
+    message: string;
+    details?: string;
+    request_id?: string;
+}
+
+export type { ValidationError };

package/dist/types/ValidationRules.d.ts

@@ -0,0 +1,96 @@
+import { ApplicableToResultList } from './ApplicableTo.js';
+
+interface ValidationRulesCreate {
+    name: string;
+    error?: {
+        message?: string;
+    };
+    rules?: {
+        logic?: string;
+        [rule: string]: any;
+    };
+}
+interface ValidationRulesCreateResponse {
+    id: string;
+    name: string;
+    error?: {
+        message?: string;
+    };
+    rules?: {
+        logic?: string;
+        [rule: string]: any;
+    };
+    created_at: string;
+    updated_at?: string;
+    object: 'validation_rules';
+}
+interface ValidationRulesValidateResponse {
+    valid: boolean;
+    rule_id: string;
+    applicable_to: ApplicableToResultList;
+}
+type ValidationRulesGetResponse = ValidationRulesCreateResponse & {
+    assignments_count?: string;
+};
+type ValidationRulesUpdate = Partial<ValidationRulesCreate> & {
+    id: string;
+};
+type ValidationRulesUpdateResponse = ValidationRulesCreateResponse;
+interface ValidationRulesCreateAssignment {
+    voucher?: string;
+    campaign?: string;
+    promotion_tier?: string;
+}
+interface ValidationRulesCreateAssignmentResponse {
+    id: string;
+    rule_id: string;
+    related_object_id?: string;
+    related_object_type?: string;
+    created_at?: string;
+    updated_at: string;
+    object: 'validation_rules_assignment';
+}
+interface ValidationRulesListParams {
+    limit?: number;
+    page?: number;
+}
+interface ValidationRulesListResponse {
+    object: 'list';
+    total: number;
+    data_ref: 'data';
+    data: ValidationRulesGetResponse[];
+}
+interface ValidationRulesListAssignmentsParams {
+    limit?: number;
+    page?: number;
+}
+interface ValidationRulesListAssignmentsResponse {
+    object: 'list';
+    total: number;
+    data_ref: 'data';
+    data: ValidationRulesCreateAssignmentResponse[];
+}
+type ValidationRulesAssignmentsList = ValidationRulesListResponse;
+interface ValidationRulesAssignment {
+    id: string;
+    rule_id: string;
+    related_object_id: string;
+    related_object_type: string;
+    created_at: string;
+    object: 'validation_rules_assignment';
+}
+interface ValidationRulesListRulesAssignmentsRequestQuery {
+    related_object_id?: string;
+    rule?: string;
+    page?: number;
+    limit?: number;
+    order?: 'created_at' | '-created_at';
+}
+interface ValidationRulesListRulesAssignmentsResponseBody {
+    object: 'list';
+    data_ref: 'data';
+    total: number;
+    data: ValidationRulesAssignment[];
+}
+
+export type { ValidationRulesAssignment, ValidationRulesAssignmentsList, ValidationRulesCreate, ValidationRulesCreateAssignment, ValidationRulesCreateAssignmentResponse, ValidationRulesCreateResponse, ValidationRulesGetResponse, ValidationRulesListAssignmentsParams, ValidationRulesListAssignmentsResponse, ValidationRulesListParams, ValidationRulesListResponse, ValidationRulesListRulesAssignmentsRequestQuery, ValidationRulesListRulesAssignmentsResponseBody, ValidationRulesUpdate, ValidationRulesUpdateResponse, ValidationRulesValidateResponse };

package/dist/types/Validations.d.ts

@@ -0,0 +1,109 @@
+import { DiscountAmount, DiscountUnit, DiscountPercent, DiscountFixed } from './DiscountVoucher.js';
+import { CustomersCreateBody } from './Customers.js';
+import { StackableOptions, StackableRedeemableParams, StackableRedeemableResponse, StackableRedeemableSkippedResponse, StackableRedeemableInapplicableResponse } from './Stackable.js';
+import { ValidationSessionParams, ValidationSessionResponse } from './ValidateSession.js';
+import { ApplicableToResultList } from './ApplicableTo.js';
+import { ValidationError } from './ValidationError.js';
+import { OrdersCreate, OrdersCreateResponse, OrdersItem } from './Orders.js';
+import { PromotionsValidateParams } from './Promotions.js';
+import './Rewards.js';
+import './Gift.js';
+import './Products.js';
+import './Loyalties.js';
+import './ValidationRules.js';
+import './Vouchers.js';
+import './Categories.js';
+import './PromotionTiers.js';
+
+interface ValidationsValidateVoucherParams {
+    customer?: {
+        id?: string;
+        source_id?: string;
+        name?: string;
+        email?: string;
+        description?: string;
+        metadata?: Record<string, any>;
+    };
+    order?: {
+        id?: string;
+        source_id?: string;
+        amount?: number;
+        items?: OrdersItem[];
+        metadata?: Record<string, any>;
+    };
+    gift?: {
+        credits: number;
+    };
+    reward?: {
+        id: string;
+    };
+    session?: ValidationSessionParams;
+}
+interface ValidationsValidateVoucherResponse {
+    applicable_to?: ApplicableToResultList;
+    inapplicable_to?: ApplicableToResultList;
+    campaign?: string;
+    campaign_id?: string;
+    metadata?: Record<string, any>;
+    code?: string;
+    valid?: boolean;
+    discount?: DiscountAmount | DiscountUnit | DiscountPercent | DiscountFixed;
+    gift?: {
+        amount: number;
+        balance: number;
+    };
+    loyalty?: {
+        points_cost: number;
+    };
+    order?: {
+        amount: number;
+        discount_amount: number;
+        total_discount_amount: number;
+        total_amount: number;
+        applied_discount_amount?: number;
+        total_applied_discount_amount?: number;
+        items?: OrdersItem[];
+        initial_amount?: number;
+        items_discount_amount?: number;
+        items_applied_discount_amount?: number;
+        metadata?: Record<string, any>;
+    };
+    session?: ValidationSessionParams;
+    start_date?: string;
+    expiration_date?: string;
+    tracking_id: string;
+    error?: ValidationError;
+}
+interface ValidationsValidateStackableParams {
+    options?: StackableOptions;
+    redeemables: StackableRedeemableParams[];
+    session?: ValidationSessionParams;
+    order?: OrdersCreate;
+    customer?: CustomersCreateBody;
+    metadata?: Record<string, any>;
+}
+interface ValidationValidateStackableResponse {
+    valid: boolean;
+    tracking_id?: string;
+    session?: ValidationSessionResponse;
+    order?: OrdersCreateResponse;
+    redeemables?: StackableRedeemableResponse[];
+    skipped_redeemables?: StackableRedeemableSkippedResponse[];
+    inapplicable_redeemables?: StackableRedeemableInapplicableResponse[];
+    stacking_rules: ValidationsStackingRules;
+}
+type ValidationsStackingRules = {
+    redeemables_limit: number;
+    applicable_redeemables_limit: number;
+    applicable_redeemables_per_category_limit?: number;
+    applicable_exclusive_redeemables_limit: number;
+    applicable_exclusive_redeemables_per_category_limit?: number;
+    exclusive_categories: string[];
+    joint_categories: string[];
+    redeemables_application_mode: 'ALL' | 'PARTIAL';
+    redeemables_sorting_rule: 'CATEGORY_HIERARCHY' | 'REQUESTED_ORDER';
+};
+type ValidationsValidateCode = PromotionsValidateParams;
+type ValidationsValidateContext = ValidationsValidateVoucherParams;
+
+export type { ValidationValidateStackableResponse, ValidationsStackingRules, ValidationsValidateCode, ValidationsValidateContext, ValidationsValidateStackableParams, ValidationsValidateVoucherParams, ValidationsValidateVoucherResponse };