import { z } from "zod";
import type { BaggageAllowance } from "../iata-types/fare.ts";
import type { CabinClass } from "../fare/types.ts";
export declare const PassengerTypeCodeSchema: z.ZodEnum<{
    ADT: "ADT";
    CHD: "CHD";
    INF: "INF";
}>;
export type PassengerTypeCode = z.infer<typeof PassengerTypeCodeSchema>;
export declare const FrequentFlyerStatusSchema: z.ZodEnum<{
    none: "none";
    bronze: "bronze";
    silver: "silver";
    gold: "gold";
    platinum: "platinum";
    diamond: "diamond";
}>;
export type FrequentFlyerStatus = z.infer<typeof FrequentFlyerStatusSchema>;
export interface PassengerBaggage {
    type: PassengerTypeCode;
    status?: FrequentFlyerStatus;
    /** Any extra pieces the passenger wants to check. */
    extraPieces?: number;
    /** Any extra weight (kg) the passenger wants to check. */
    extraWeightKg?: number;
}
export declare const BaggageItemSchema: z.ZodObject<{
    weightKg: z.ZodNumber;
    linearCm: z.ZodOptional<z.ZodNumber>;
    isSpecialItem: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
export type BaggageItem = z.infer<typeof BaggageItemSchema>;
export declare const BaggageFeeLineSchema: z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    amount: z.ZodNumber;
    currency: z.ZodString;
}, z.core.$strip>;
export type BaggageFeeLine = z.infer<typeof BaggageFeeLineSchema>;
export interface BaggageFeeProfile {
    /** Region or airline identifier. */
    region: string;
    /**
     * Calculate excess baggage fees.
     *
     * @param params.allowance     The free allowance from the fare/ticket.
     * @param params.actualItems   The actual baggage items presented.
     * @param params.cabinClass    Cabin class of the ticket.
     * @param params.passengerType Passenger type (ADT/CHD/INF).
     * @param params.status        Frequent flyer status.
     * @param params.currency      Currency for fee calculation.
     */
    calculateFees(params: {
        allowance: BaggageAllowance;
        actualItems: BaggageItem[];
        cabinClass: CabinClass;
        passengerType: PassengerTypeCode;
        status: FrequentFlyerStatus;
        currency: string;
    }): BaggageFeeLine[];
}
export declare const BaggageFeeProfileSchema: z.ZodObject<{
    region: z.ZodString;
}, z.core.$strip>;
export type BaggageFeeProfileType = z.infer<typeof BaggageFeeProfileSchema>;
/**
 * Universal default fee profile.
 *
 * Rules:
 * - Excess piece: flat fee per extra bag.
 * - Excess weight: per-kg charge for weight over allowance.
 * - Overweight bag (>32kg): penalty per bag.
 * - Oversize bag (>158cm linear): penalty per bag.
 */
export declare const DEFAULT_FEE_PROFILE: BaggageFeeProfile;
export declare const AU_FEE_PROFILE: BaggageFeeProfile;
export declare const US_FEE_PROFILE: BaggageFeeProfile;
export declare const EU_FEE_PROFILE: BaggageFeeProfile;
export declare function registerBaggageFeeProfile(profile: BaggageFeeProfile): void;
export declare function getBaggageFeeProfile(region: string): BaggageFeeProfile | undefined;
export interface CalculateBaggageParams {
    /** The free baggage allowance from the ticket/fare. */
    allowance: BaggageAllowance;
    /** Actual baggage items presented by the passenger. */
    actualItems: BaggageItem[];
    /** Cabin class — affects per-piece weight limits. */
    cabinClass: CabinClass;
    /** Passenger type — ADT/CHD/INF may have different allowances. */
    passengerType: PassengerTypeCode;
    /** Frequent flyer status — may add extra allowance. */
    status?: FrequentFlyerStatus;
    /** Region for fee lookup (AU, US, EU, etc.). */
    region?: string;
    /** Explicit currency override for fees. */
    currency?: string;
}
export interface BaggageCalculationResult {
    /** Whether the baggage is within the free allowance. */
    withinAllowance: boolean;
    /** Free allowance after adjustments (status, passenger type). */
    effectiveAllowance: BaggageAllowance;
    /** Total weight of actual items. */
    actualWeightKg: number;
    /** Number of actual pieces. */
    actualPieces: number;
    /** Excess weight (kg) if weight concept. */
    excessWeightKg: number;
    /** Excess pieces if piece concept. */
    excessPieces: number;
    /** Number of overweight bags (>32kg). */
    overweightBags: number;
    /** Number of oversize bags (>158cm). */
    oversizeBags: number;
    /** Calculated fees for any excess. */
    fees: BaggageFeeLine[];
    /** Total fee amount. */
    totalFees: number;
    currency: string;
}
/**
 * Calculate baggage allowance usage and excess fees.
 *
 * Handles both piece and weight concepts, mixing/matching,
 * passenger type and frequent flyer status adjustments.
 */
export declare function calculateBaggage(params: CalculateBaggageParams): BaggageCalculationResult;
//# sourceMappingURL=baggage.d.ts.map