import { BackInStockNotificationForm, IkasAppliedCampaignAmount, IkasProductAttributeMap, IkasProductPrice, IkasProductVariant, IkasTieredDiscountProduct } from "../../../../storefront-models/src";
/**
 * Get the main/primary media item for a product variant.
 *
 * The returned IkasProductImage may be a video (`isVideo === true`) — branch on it
 * and render `<video>` instead of `<img>`.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getSelectedProductVariant
 *
 * @param variant - The product variant
 * @returns The first IkasProductImage of the variant, or undefined if no images. Check `.isVideo` to decide between `<video>` and `<img>`, and access `.image` to get the IkasImage for CDN helpers.
 *
 * @example
 * ```typescript
 * import { getProductVariantMainImage, getSelectedProductVariant, getDefaultSrc, createMediaSrcset } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function ProductImage({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const productImage = getProductVariantMainImage(variant);
 *   const image = productImage?.image;
 *
 *   if (!image) {
 *     return <div className="no-image">No image available</div>;
 *   }
 *
 *   // Media can be a video — branch on isVideo:
 *   return productImage.isVideo ? (
 *     <video src={getDefaultSrc(image)} muted playsInline loop>
 *       <track kind="captions" />
 *     </video>
 *   ) : (
 *     <img src={getDefaultSrc(image)} srcSet={createMediaSrcset(image)} alt={product.name} />
 *   );
 * }
 * ```
 */
export declare function getProductVariantMainImage(variant: IkasProductVariant): import("../../../../storefront-models/src").IkasProductImage | undefined;
/**
 * Check if a specific product variant has stock available.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getSelectedProductVariant, addItemToCart
 *
 * @param variant - The product variant to check
 * @returns True if variant has stock or allows selling when out of stock
 *
 * @example
 * ```typescript
 * import { hasProductVariantStock, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function AddToCartButton({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const hasStock = hasProductVariantStock(variant);
 *
 *   return (
 *     <button disabled={!hasStock}>
 *       {hasStock ? "Add to Cart" : "Out of Stock"}
 *     </button>
 *   );
 * }
 * ```
 */
export declare function hasProductVariantStock(variant: IkasProductVariant): boolean;
/**
 * Get grouped attribute values for a product variant, organized by attribute ID.
 *
 * @ai-category ProductVariant, ProductDetail
 * @ai-related getSelectedProductVariant
 *
 * @param variant - The product variant whose attributes to group
 * @returns An array of attribute maps, each containing the attribute and its grouped values
 *
 * @example
 * ```typescript
 * import { getGroupedAttributeValuesForVariant, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function VariantAttributes({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const groupedAttributes = getGroupedAttributeValuesForVariant(variant);
 *
 *   return (
 *     <ul>
 *       {groupedAttributes.map((attr) => (
 *         <li key={attr.attribute.id}>{attr.attribute.name}: {attr.values.map(v => v.value).join(", ")}</li>
 *       ))}
 *     </ul>
 *   );
 * }
 * ```
 */
export declare function getGroupedAttributeValuesForVariant(variant: IkasProductVariant): IkasProductAttributeMap[];
/**
 * Get the applicable B2B price list rule for a product variant based on the current customer.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantPrice, getProductVariantFinalPrice
 *
 * @param variant - The product variant to evaluate against B2B price rules
 * @returns The matching price list rule, or null if no rule applies or no customer is logged in
 *
 * @example
 * ```typescript
 * import { getProductVariantB2bPriceRule, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function B2BPriceInfo({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const priceRule = getProductVariantB2bPriceRule(variant);
 *
 *   if (priceRule) {
 *     return <span>B2B pricing applied: {priceRule.valueType}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantB2bPriceRule(variant: IkasProductVariant): import("../../../../storefront-models/src").IkasCustomerPriceListRule | null;
/**
 * Get the applicable price object for a product variant based on the storefront or B2B customer price list.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFinalPrice, getProductVariantSellPrice, getProductVariantBundlePrice
 *
 * @param variant - The product variant whose price to retrieve
 * @returns The matching IkasProductPrice for the current storefront or B2B customer
 *
 * @example
 * ```typescript
 * import { getProductVariantPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function PriceCurrency({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const price = getProductVariantPrice(variant);
 *
 *   return <span>Currency: {price.currency}</span>;
 * }
 * ```
 */
export declare function getProductVariantPrice(variant: IkasProductVariant): IkasProductPrice;
/**
 * Check if a product variant has bundle settings configured.
 *
 * @ai-category ProductVariant, ProductDetail
 * @ai-related getProductVariantBundlePrice, getProductVariantFinalPrice
 *
 * @param variant - The product variant to check
 * @returns True if the variant has bundle settings, false otherwise
 *
 * @example
 * ```typescript
 * import { hasBundleSettings, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BundleIndicator({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (hasBundleSettings(variant)) {
 *     return <span className="bundle-badge">Bundle</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function hasBundleSettings(variant: IkasProductVariant): boolean;
/**
 * Get the base bundle price for a product variant, considering B2B and storefront price lists.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related hasBundleSettings, getProductVariantPrice, getProductVariantFinalPrice
 *
 * @param variant - The product variant whose bundle price to retrieve
 * @returns The bundle price object, or falls back to the regular variant price if no bundle price exists
 *
 * @example
 * ```typescript
 * import { getProductVariantBundlePrice, hasBundleSettings, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BundlePrice({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (hasBundleSettings(variant)) {
 *     const bundlePrice = getProductVariantBundlePrice(variant);
 *     return <span>Bundle base: {bundlePrice.sellPrice}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantBundlePrice(variant: IkasProductVariant): IkasProductPrice;
/**
 * Get the final price of a variant after all discounts and campaigns.
 * Use this for calculations. For display, use getProductVariantFormattedFinalPrice.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getProductVariantFormattedFinalPrice, getProductVariantSellPrice, hasProductVariantDiscount
 *
 * @param variant - The product variant
 * @returns The final price as a number
 *
 * @example
 * ```typescript
 * import { getProductVariantFinalPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function calculateTotal(product: IkasProduct, quantity: number) {
 *   const variant = getSelectedProductVariant(product);
 *   const unitPrice = getProductVariantFinalPrice(variant);
 *   return unitPrice * quantity;
 * }
 * ```
 */
export declare function getProductVariantFinalPrice(variant: IkasProductVariant): number;
/**
 * Get the formatted final price string with currency symbol.
 * Use this for displaying prices in the UI.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getProductVariantFinalPrice, getProductVariantFormattedSellPrice, hasProductVariantDiscount
 *
 * @param variant - The product variant
 * @returns Formatted price string (e.g., "$19.99" or "€15,00")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedFinalPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function PriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   return (
 *     <span className="price">
 *       {getProductVariantFormattedFinalPrice(variant)}
 *     </span>
 *   );
 * }
 * ```
 */
export declare function getProductVariantFormattedFinalPrice(variant: IkasProductVariant): string;
/**
 * Get the original sell price of a variant (before discounts).
 * Use this to show the original price when displaying discounts.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getProductVariantFormattedSellPrice, getProductVariantFinalPrice, hasProductVariantDiscount
 *
 * @param variant - The product variant
 * @returns The original sell price as a number
 *
 * @example
 * ```typescript
 * import {
 *   getProductVariantSellPrice,
 *   getProductVariantFinalPrice,
 *   hasProductVariantDiscount
 * } from "@ikas/bp-storefront";
 *
 * function calculateDiscount(variant: IkasProductVariant) {
 *   if (hasProductVariantDiscount(variant)) {
 *     const original = getProductVariantSellPrice(variant);
 *     const final = getProductVariantFinalPrice(variant);
 *     return original - final;
 *   }
 *   return 0;
 * }
 * ```
 */
export declare function getProductVariantSellPrice(variant: IkasProductVariant): number;
/**
 * Get the formatted original sell price with currency symbol.
 * Use this to display the original price with a strikethrough when showing discounts.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getProductVariantSellPrice, getProductVariantFormattedFinalPrice, hasProductVariantDiscount
 *
 * @param variant - The product variant
 * @returns Formatted price string (e.g., "$29.99")
 *
 * @example
 * ```typescript
 * import {
 *   getProductVariantFormattedSellPrice,
 *   getProductVariantFormattedFinalPrice,
 *   hasProductVariantDiscount,
 *   getSelectedProductVariant
 * } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function PriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const hasDiscount = hasProductVariantDiscount(variant);
 *
 *   return (
 *     <div>
 *       {hasDiscount && (
 *         <span className="original-price" style={{ textDecoration: "line-through" }}>
 *           {getProductVariantFormattedSellPrice(variant)}
 *         </span>
 *       )}
 *       <span className="final-price">
 *         {getProductVariantFormattedFinalPrice(variant)}
 *       </span>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function getProductVariantFormattedSellPrice(variant: IkasProductVariant): string;
/**
 * Get the formatted buy (cost) price of a product variant with currency symbol.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantPrice, getProductVariantFormattedSellPrice, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant whose buy price to format
 * @returns Formatted buy price string with currency symbol (e.g., "$10.00")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedBuyPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BuyPriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const formattedBuyPrice = getProductVariantFormattedBuyPrice(variant);
 *
 *   return <span>Cost: {formattedBuyPrice}</span>;
 * }
 * ```
 */
export declare function getProductVariantFormattedBuyPrice(variant: IkasProductVariant): string;
/**
 * Get the applied campaign discount amount details for a product variant, including type and formatted value.
 *
 * How the discount value is interpreted depends on `campaign.type`:
 * - `"FIXED_AMOUNT"` → the value is an absolute money amount, returned in `formattedPrice` (e.g. "$10.00"); `discountPercentage` stays null.
 * - `"RATIO"` → the value is a percentage, returned in `discountPercentage` (e.g. "10" for 10% off); `formattedPrice` stays null.
 *
 * Both fixed and tiered campaigns are supported. For a tiered-discount campaign
 * (`campaign.fixedDiscount` is null and the discount lives in `campaign.tieredDiscount.rules`),
 * the first tier's amount (`campaign.tieredDiscount.rules[0].amount`) is used, matching the storefront runtime.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantCampaignPrice, getProductVariantFormattedCampaignPrice, hasProductVariantDiscount
 *
 * @param variant - The product variant to check for applied campaigns
 * @returns An object `{ type, formattedPrice, discountPercentage }` — `formattedPrice` is set for FIXED_AMOUNT campaigns, `discountPercentage` for RATIO campaigns (fixed and tiered alike); the other field stays null. Returns null if no campaign is applied.
 *
 * @example
 * ```typescript
 * import { getProductVariantAppliedCampaignAmount, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function CampaignInfo({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const campaignAmount = getProductVariantAppliedCampaignAmount(variant);
 *
 *   if (!campaignAmount) return null;
 *
 *   return (
 *     <div>
 *       {campaignAmount.type === "RATIO"
 *         ? `${campaignAmount.discountPercentage}% off`
 *         : `${campaignAmount.formattedPrice} off`}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function getProductVariantAppliedCampaignAmount(variant: IkasProductVariant): IkasAppliedCampaignAmount | null;
/**
 * Get the raw campaign price value for a product variant.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFormattedCampaignPrice, getProductVariantAppliedCampaignAmount, getProductVariantPrice
 *
 * @param variant - The product variant whose campaign price to retrieve
 * @returns The campaign price as a number, or null if no campaign price is set
 *
 * @example
 * ```typescript
 * import { getProductVariantCampaignPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function CampaignPriceCheck({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const campaignPrice = getProductVariantCampaignPrice(variant);
 *
 *   if (campaignPrice !== null) {
 *     return <span>Campaign price: {campaignPrice}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantCampaignPrice(variant: IkasProductVariant): number | null;
/**
 * Get the formatted campaign price string with currency symbol for a product variant.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantCampaignPrice, getProductVariantAppliedCampaignAmount, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant whose campaign price to format
 * @returns Formatted campaign price string with currency symbol (e.g., "$14.99")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedCampaignPrice, getProductVariantCampaignPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function CampaignPriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const campaignPrice = getProductVariantCampaignPrice(variant);
 *
 *   if (campaignPrice !== null) {
 *     return <span>Campaign: {getProductVariantFormattedCampaignPrice(variant)}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantFormattedCampaignPrice(variant: IkasProductVariant): string;
/**
 * Get the discounted price of a product variant, or null if there is no discount.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related hasProductVariantDiscount, getProductVariantFormattedDiscountPrice, getProductVariantFinalPrice, getProductVariantSellPrice
 *
 * @param variant - The product variant to check for a discount price
 * @returns The discounted final price as a number, or null if the final price equals the sell price
 *
 * @example
 * ```typescript
 * import { getProductVariantDiscountPrice, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function DiscountPriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const discountPrice = getProductVariantDiscountPrice(variant);
 *
 *   if (discountPrice !== null) {
 *     return <span className="discount-price">{discountPrice}</span>;
 *   }
 *   return <span>No discount available</span>;
 * }
 * ```
 */
export declare function getProductVariantDiscountPrice(variant: IkasProductVariant): number | null;
/**
 * Get the formatted discounted price string with currency symbol for a product variant.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantDiscountPrice, hasProductVariantDiscount, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant whose discount price to format
 * @returns Formatted discount price string with currency symbol (e.g., "$17.99")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedDiscountPrice, hasProductVariantDiscount, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function FormattedDiscountPrice({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (hasProductVariantDiscount(variant)) {
 *     return <span className="sale-price">{getProductVariantFormattedDiscountPrice(variant)}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantFormattedDiscountPrice(variant: IkasProductVariant): string;
/**
 * Check if a variant has a discount applied.
 * Use this to conditionally show sale badges or original prices.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related getProductVariantDiscountPercentage, getProductVariantFormattedSellPrice, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant
 * @returns True if variant has a discount
 *
 * @example
 * ```typescript
 * import { hasProductVariantDiscount, getProductVariantDiscountPercentage, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function SaleBadge({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (!hasProductVariantDiscount(variant)) {
 *     return null;
 *   }
 *
 *   const discountPercent = getProductVariantDiscountPercentage(variant);
 *   return <span className="sale-badge">-{discountPercent}%</span>;
 * }
 * ```
 */
export declare function hasProductVariantDiscount(variant: IkasProductVariant): boolean;
/**
 * Get the formatted discount amount string with currency symbol, showing how much the customer saves.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantDiscountAmount, hasProductVariantDiscount, getProductVariantDiscountPercentage
 *
 * @param variant - The product variant whose discount amount to format
 * @returns Formatted discount amount string with currency symbol (e.g., "$5.00")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedDiscountAmount, hasProductVariantDiscount, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function SavingsDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (hasProductVariantDiscount(variant)) {
 *     return <span>You save: {getProductVariantFormattedDiscountAmount(variant)}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantFormattedDiscountAmount(variant: IkasProductVariant): string;
/**
 * Get the absolute discount amount for a variant.
 *
 * @ai-category ProductDetail
 * @ai-related hasProductVariantDiscount, getProductVariantDiscountPercentage, getProductVariantFormattedDiscountAmount
 *
 * @param variant - The product variant
 * @returns Discount amount as a number (0 if no discount)
 *
 * @example
 * ```typescript
 * import { getProductVariantDiscountAmount, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function SavingsDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const savings = getProductVariantDiscountAmount(variant);
 *
 *   if (savings > 0) {
 *     return <p>You save: ${savings.toFixed(2)}</p>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantDiscountAmount(variant: IkasProductVariant): number;
/**
 * Get the discount percentage for a variant.
 * Returns a string like "20" for a 20% discount.
 *
 * @ai-category ProductDetail, ProductList
 * @ai-related hasProductVariantDiscount, getProductVariantDiscountAmount
 *
 * @param variant - The product variant
 * @returns Discount percentage as a string (e.g., "20")
 *
 * @example
 * ```typescript
 * import { getProductVariantDiscountPercentage, hasProductVariantDiscount, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function DiscountBadge({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (!hasProductVariantDiscount(variant)) {
 *     return null;
 *   }
 *
 *   return (
 *     <div className="discount-badge">
 *       Save {getProductVariantDiscountPercentage(variant)}%
 *     </div>
 *   );
 * }
 * ```
 */
export declare function getProductVariantDiscountPercentage(variant: IkasProductVariant): string;
/**
 * Get the final price of a product variant including prices from selected campaign offer products.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFormattedFinalPriceWithCampaignOffers, getProductVariantSellPriceWithCampaignOffers, getProductVariantFinalPrice
 *
 * @param variant - The product variant whose total final price with campaign offers to calculate
 * @returns The total final price including all selected campaign offer products
 *
 * @example
 * ```typescript
 * import { getProductVariantFinalPriceWithCampaignOffers, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function TotalWithOffers({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const totalPrice = getProductVariantFinalPriceWithCampaignOffers(variant);
 *
 *   return <span>Total with offers: {totalPrice}</span>;
 * }
 * ```
 */
export declare function getProductVariantFinalPriceWithCampaignOffers(variant: IkasProductVariant): number;
/**
 * Get the formatted final price string with currency symbol, including selected campaign offer products.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFinalPriceWithCampaignOffers, getProductVariantFormattedSellPriceWithCampaignOffers, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant whose formatted total price with campaign offers to retrieve
 * @returns Formatted total price string with currency symbol (e.g., "$34.99")
 *
 * @example
 * ```typescript
 * import { getProductVariantFormattedFinalPriceWithCampaignOffers, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function FormattedTotalWithOffers({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   return (
 *     <span className="total-price">
 *       {getProductVariantFormattedFinalPriceWithCampaignOffers(variant)}
 *     </span>
 *   );
 * }
 * ```
 */
export declare function getProductVariantFormattedFinalPriceWithCampaignOffers(variant: IkasProductVariant): string;
/**
 * Get the original sell price of a product variant including prices from selected campaign offer products.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFormattedSellPriceWithCampaignOffers, getProductVariantFinalPriceWithCampaignOffers, getProductVariantSellPrice
 *
 * @param variant - The product variant whose total sell price with campaign offers to calculate
 * @returns The total sell price including all selected campaign offer products
 *
 * @example
 * ```typescript
 * import { getProductVariantSellPriceWithCampaignOffers, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function OriginalTotalWithOffers({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const totalSellPrice = getProductVariantSellPriceWithCampaignOffers(variant);
 *
 *   return <span>Original total: {totalSellPrice}</span>;
 * }
 * ```
 */
export declare function getProductVariantSellPriceWithCampaignOffers(variant: IkasProductVariant): number;
/**
 * Get the formatted original sell price string with currency symbol, including selected campaign offer products.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantSellPriceWithCampaignOffers, getProductVariantFormattedFinalPriceWithCampaignOffers, getProductVariantFormattedSellPrice
 *
 * @param variant - The product variant whose formatted total sell price with campaign offers to retrieve
 * @returns Formatted total sell price string with currency symbol (e.g., "$49.99")
 *
 * @example
 * ```typescript
 * import {
 *   getProductVariantFormattedSellPriceWithCampaignOffers,
 *   getProductVariantFormattedFinalPriceWithCampaignOffers,
 *   getSelectedProductVariant
 * } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function PriceWithOffers({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   return (
 *     <div>
 *       <span style={{ textDecoration: "line-through" }}>
 *         {getProductVariantFormattedSellPriceWithCampaignOffers(variant)}
 *       </span>
 *       <span>{getProductVariantFormattedFinalPriceWithCampaignOffers(variant)}</span>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function getProductVariantFormattedSellPriceWithCampaignOffers(variant: IkasProductVariant): string;
/**
 * Get the discount percentage when campaign offer products are included in the total price calculation.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantFinalPriceWithCampaignOffers, getProductVariantSellPriceWithCampaignOffers, getProductVariantDiscountPercentage
 *
 * @param variant - The product variant whose campaign offers discount percentage to calculate
 * @returns The discount percentage as a number (e.g., 20 for 20%), or 0 if there is no discount
 *
 * @example
 * ```typescript
 * import { getProductVariantCampaignOffersDiscountPercentage, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function CampaignOffersDiscount({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const discountPercent = getProductVariantCampaignOffersDiscountPercentage(variant);
 *
 *   if (discountPercent > 0) {
 *     return <span className="discount-badge">-{discountPercent}%</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantCampaignOffersDiscountPercentage(variant: IkasProductVariant): number;
/**
 * Get the tiered-discount breakdown for a product variant, one entry per discount tier.
 *
 * A tiered discount defines multiple quantity tiers (`campaign.tieredDiscount.rules`), each with its own
 * amount and quantity range. This resolves every tier against the variant's price and returns the
 * per-tier sell/final prices (both raw numbers and formatted strings), matching the storefront runtime.
 * The raw rules are `IkasProductTieredDiscountRule` (ranges may be null); this function returns the
 * resolved `IkasTieredDiscountProduct` with normalized `{ min, max }` — use the resolved shape, not the raw rule.
 *
 * `sellPrice`/`finalPrice` (and their `formatted*` variants) are PER UNIT; the `*WithQuantity` fields are the
 * tier total for buying the minimum quantity. A `"FIXED_AMOUNT"` discount is applied only to that total, so
 * per-unit `finalPrice` equals `sellPrice` and the saving shows only in `finalPriceWithQuantity`.
 *
 * The discount `amount` is interpreted by `campaign.type`: `"RATIO"` treats it as a percentage,
 * `"FIXED_AMOUNT"` as an absolute money amount subtracted from the tier total. `amount`/`type` are
 * informational — the discount is already applied in the resolved `*Price` fields, so prefer those over
 * recomputing it yourself.
 *
 * `lineItemQuantityRange.min`/`max` are normalized numbers where `0` means "unbounded". In particular
 * `max === 0` marks an open-ended top tier (e.g. "6+" with no upper limit) — render it as "min+" rather
 * than "min–max", and never treat `max` as a real quantity when it is `0`.
 *
 * Each tier's `salesChannelIds` lists the channels it targets (empty/null = all channels). Filter tiers
 * against `IkasStorefrontConfig.salesChannelId` so only those valid for the current storefront are shown.
 *
 * Returns an empty array when the variant has no tiered-discount campaign, when a
 * `PRODUCT_AND_VARIANT` filter excludes this variant, or when no tier defines a quantity range.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantAppliedCampaignAmount, getProductVariantCampaignOffersDiscountPercentage, getProductVariantFinalPrice
 *
 * @param variant - The product variant to resolve tiered discounts for
 * @returns An array of tier objects (`amount`, `lineItemQuantityRange`, `type`, sell/final prices with their formatted variants, `salesChannelIds`), or an empty array if no tiered discount applies
 *
 * @example
 * ```typescript
 * import {
 *   getProductVariantTieredDiscountProducts,
 *   getSelectedProductVariant,
 *   IkasStorefrontConfig,
 * } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function TieredDiscountTable({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const tiers = getProductVariantTieredDiscountProducts(variant);
 *   const salesChannelId = IkasStorefrontConfig.salesChannelId;
 *
 *   if (!tiers.length) return null;
 *
 *   return (
 *     <ul>
 *       {tiers.map((tier, i) => {
 *         // A tier applies when it targets no channels or includes the current one
 *         const scoped =
 *           !tier.salesChannelIds?.length ||
 *           (!!salesChannelId && tier.salesChannelIds.includes(salesChannelId));
 *         if (!scoped) return null;
 *
 *         return (
 *           <li key={i}>
 *             Buy {tier.lineItemQuantityRange.min}+ → {tier.formattedFinalPriceWithQuantity}{" "}
 *             <s>{tier.formattedSellPriceWithQuantity}</s>
 *           </li>
 *         );
 *       })}
 *     </ul>
 *   );
 * }
 * ```
 */
export declare function getProductVariantTieredDiscountProducts(variant: IkasProductVariant): IkasTieredDiscountProduct[];
/**
 * Check if the back-in-stock notification feature is enabled for the storefront.
 *
 * @ai-category Stock, Inventory
 * @ai-related getProductVariantIsBackInStockCustomerLoginRequired, saveProductVariantBackInStockReminder, getProductVariantBackInStockForm, hasProductVariantStock
 *
 * @param variant - The product variant (used for context)
 * @returns True if back-in-stock notifications are enabled in the storefront configuration
 *
 * @example
 * ```typescript
 * import { getProductVariantIsBackInStockEnabled, hasProductVariantStock, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BackInStockSection({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (!hasProductVariantStock(variant) && getProductVariantIsBackInStockEnabled(variant)) {
 *     return <div>Sign up to be notified when this item is back in stock!</div>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantIsBackInStockEnabled(variant: IkasProductVariant): boolean;
/**
 * Check if customer login is required to subscribe to back-in-stock notifications.
 *
 * @ai-category Stock, Inventory
 * @ai-related getProductVariantIsBackInStockEnabled, saveProductVariantBackInStockReminder, getProductVariantBackInStockForm
 *
 * @param variant - The product variant (used for context)
 * @returns True if customer login is required for back-in-stock notification subscriptions
 *
 * @example
 * ```typescript
 * import {
 *   getProductVariantIsBackInStockCustomerLoginRequired,
 *   getProductVariantIsBackInStockEnabled,
 *   getSelectedProductVariant
 * } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BackInStockForm({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *
 *   if (!getProductVariantIsBackInStockEnabled(variant)) return null;
 *
 *   if (getProductVariantIsBackInStockCustomerLoginRequired(variant)) {
 *     return <p>Please log in to subscribe to back-in-stock notifications.</p>;
 *   }
 *   return <input type="email" placeholder="Enter your email" />;
 * }
 * ```
 */
export declare function getProductVariantIsBackInStockCustomerLoginRequired(variant: IkasProductVariant): boolean | null | undefined;
/**
 * Save a back-in-stock reminder for a product variant, notifying the customer via email when stock is replenished.
 *
 * @ai-category Stock, Inventory
 * @ai-related getProductVariantIsBackInStockEnabled, getProductVariantIsBackInStockCustomerLoginRequired, getProductVariantBackInStockForm, hasProductVariantStock
 *
 * @param variant - The out-of-stock product variant to watch
 * @param email - The email address to notify when the product is back in stock
 * @returns True if the reminder was successfully created, false if it already exists or creation failed
 *
 * @example
 * ```typescript
 * import { saveProductVariantBackInStockReminder, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * async function handleBackInStockSubmit(product: IkasProduct, email: string) {
 *   const variant = getSelectedProductVariant(product);
 *   const success = await saveProductVariantBackInStockReminder(variant, email);
 *
 *   if (success) {
 *     alert("You will be notified when this product is back in stock!");
 *   } else {
 *     alert("A reminder already exists or could not be created.");
 *   }
 * }
 * ```
 */
export declare function saveProductVariantBackInStockReminder(variant: IkasProductVariant, email: string): Promise<boolean>;
/**
 * Get the formatted unit price text for a product variant, including the base amount and unit name.
 *
 * @ai-category Pricing, ProductVariant
 * @ai-related getProductVariantPrice, getProductVariantFormattedFinalPrice
 *
 * @param variant - The product variant whose unit price text to generate
 * @returns A formatted string like "$2.50 / 100g", or undefined if no unit price or base unit is set, or "0" if the product is not found
 *
 * @example
 * ```typescript
 * import { getProductVariantUnitPriceText, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function UnitPriceDisplay({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const unitPriceText = getProductVariantUnitPriceText(variant);
 *
 *   if (unitPriceText) {
 *     return <span className="unit-price">{unitPriceText}</span>;
 *   }
 *   return null;
 * }
 * ```
 */
export declare function getProductVariantUnitPriceText(variant: IkasProductVariant): string | undefined;
/**
 * Get or initialize the back-in-stock notification form for a product variant.
 *
 * @ai-category Stock, Inventory
 * @ai-related clearProductVariantBackInStockForm, saveProductVariantBackInStockReminder, getProductVariantIsBackInStockEnabled
 *
 * @param variant - The product variant whose back-in-stock form to retrieve or create
 * @returns The BackInStockNotificationForm instance for the variant
 *
 * @example
 * ```typescript
 * import { getProductVariantBackInStockForm, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * function BackInStockFormComponent({ product }: { product: IkasProduct }) {
 *   const variant = getSelectedProductVariant(product);
 *   const form = getProductVariantBackInStockForm(variant);
 *
 *   return (
 *     <form>
 *       <input
 *         type="email"
 *         value={form.email}
 *         placeholder="Enter your email"
 *       />
 *       <button type="submit">Notify Me</button>
 *     </form>
 *   );
 * }
 * ```
 */
export declare function getProductVariantBackInStockForm(variant: IkasProductVariant): BackInStockNotificationForm;
/**
 * Clear and remove the back-in-stock notification form data for a product variant.
 *
 * @ai-category Stock, Inventory
 * @ai-related getProductVariantBackInStockForm, saveProductVariantBackInStockReminder, getProductVariantIsBackInStockEnabled
 *
 * @param variant - The product variant whose back-in-stock form to clear
 * @returns void
 *
 * @example
 * ```typescript
 * import { clearProductVariantBackInStockForm, saveProductVariantBackInStockReminder, getSelectedProductVariant } from "@ikas/bp-storefront";
 * import { IkasProduct } from "@ikas/bp-storefront";
 *
 * async function handleSubmitAndReset(product: IkasProduct, email: string) {
 *   const variant = getSelectedProductVariant(product);
 *   const success = await saveProductVariantBackInStockReminder(variant, email);
 *
 *   if (success) {
 *     clearProductVariantBackInStockForm(variant);
 *   }
 * }
 * ```
 */
export declare function clearProductVariantBackInStockForm(variant: IkasProductVariant): void;