import { AutoEncoder, Data, EncodeContext, PlainObject } from '@simonbackx/simple-encoding';
import { CartItem, CartItemPrice } from './CartItem.js';
import { Checkout } from './Checkout.js';
import { Webshop } from './Webshop.js';
import { OptionMenu, Option } from './Product.js';
export declare enum OptionSelectionRequirement {
    Required = "Required",
    Optional = "Optional",
    Excluded = "Excluded"
}
export declare class OptionSelectionRequirementHelper {
    static getName(requirement: OptionSelectionRequirement): string;
}
export declare class ProductSelector extends AutoEncoder {
    productId: string;
    /**
     * Empty array = doesn't matter
     * Array set = required one of the product prices from the list
     */
    productPriceIds: string[];
    /**
     * Options that are missing in the list get a default value
     * depending whether the option menu is multiple choice or not.
     *
     * For multiple choice:
     * - new options are optional
     *
     * For choose one:
     * - new options are exluded unless all options are optional
     */
    optionIds: Map<string, OptionSelectionRequirement>;
    getOptionRequirement(optionMenu: OptionMenu, option: Option): OptionSelectionRequirement;
    doesMatch(cartItem: CartItem): boolean;
    getName(webshop: Webshop, isAdmin?: boolean): {
        name: string;
        footnote: string;
    };
}
export declare class ProductsSelector extends AutoEncoder {
    products: ProductSelector[];
    doesMatch(cartItem: CartItem): boolean;
    getName(webshop: Webshop, isAdmin?: boolean): {
        name: string;
        footnote: string;
    };
    static decode<T extends typeof AutoEncoder>(this: T, data: Data): InstanceType<T>;
    encode(context: EncodeContext): PlainObject;
}
export declare class DiscountRequirement extends AutoEncoder {
    id: string;
    product: ProductsSelector;
    /**
     * Minimum amount to trigger this requirement
     */
    amount: number;
    /**
     * Requirements can match multiple times (for X + Y discount systems)
     */
    getMatchCount(checkout: Checkout): number;
}
export declare class GeneralDiscount extends AutoEncoder {
    /**
     * Fixed discount on order
     */
    fixedDiscount: number;
    /**
     * Percentage discount on order, in pertenthousand 1 / 10 000
     * 10 = 0,1% discount
     * 1 = 0,01% discount
     */
    percentageDiscount: number;
    multiply(amount: number): GeneralDiscount;
}
export declare class ProductDiscount extends AutoEncoder {
    /**
     * Id determines uniqueness so should not be reused between discounts
     */
    id: string;
    discountPerPiece: number;
    /**
     * Percentage discount on order, in pertenthousand 1 / 10 000
     * 10 = 0,1% discount
     * 1 = 0,01% discount
     */
    percentageDiscount: number;
    calculate(price: number): number;
    applyTo(item: CartItemPrice): void;
    calculatePotential(item: CartItemPrice): number;
}
export declare enum ProductDiscountRepeatBehaviour {
    Once = "Once",
    RepeatLast = "RepeatLast",
    RepeatPattern = "RepeatPattern"
}
export declare class ProductDiscountSettings extends AutoEncoder {
    id: string;
    product: ProductsSelector;
    discounts: ProductDiscount[];
    repeatBehaviour: ProductDiscountRepeatBehaviour;
    cartLabel: string | null;
    allowMultipleDiscountsToSameItem: boolean;
    getApplicableDiscounts(offset: number, amount: number): ProductDiscount[];
    getTitle(webshop: Webshop, isAdmin?: boolean): {
        title: string;
        description: string;
        footnote: string;
    };
}
export declare class ProductDiscountTracker {
    discount: ProductDiscountSettings;
    usageCount: number;
    cartItemQueue: {
        price: CartItemPrice;
        item: CartItem;
    }[];
    constructor(discount: ProductDiscountSettings);
    getNextDiscount(offset?: number): ProductDiscount | null;
    sortQueue(): void;
    get filteredQueue(): {
        price: CartItemPrice;
        item: CartItem;
    }[];
    apply(): void;
    addItemToQueue(cartItem: CartItem): void;
    getPotentialDiscount(): number;
}
export declare class Discount extends AutoEncoder {
    id: string;
    /**
     * Empty list = no requirements
     */
    requirements: DiscountRequirement[];
    /**
     * If the requirements match x times, apply the discount x times
     */
    applyMultipleTimes: boolean;
    orderDiscount: GeneralDiscount;
    productDiscounts: ProductDiscountSettings[];
    getTitle(webshop: Webshop, isAdmin?: boolean): {
        title: string;
        description: string;
        footnote: string;
    };
    applyToCheckout(checkout: Checkout): ProductDiscountTracker[];
}
//# sourceMappingURL=Discount.d.ts.map