@almatar/smart-booking-dashboard 0.0.1

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@almatar/smart-booking-dashboard" />
+export * from './public-api';

package/lib/components/action-card/action-card.component.d.ts

@@ -0,0 +1,10 @@
+import { ActionConfig } from '../../models/action.types';
+import * as i0 from "@angular/core";
+export declare class SbdActionCardComponent {
+    action: import("@angular/core").InputSignal<ActionConfig>;
+    active: import("@angular/core").InputSignal<boolean>;
+    loading: import("@angular/core").InputSignal<boolean>;
+    selected: import("@angular/core").OutputEmitterRef<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdActionCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdActionCardComponent, "app-sbd-action-card", never, { "action": { "alias": "action"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}

package/lib/components/action-dialog/action-dialog.component.d.ts

@@ -0,0 +1,26 @@
+import { ActionConfig, ResultContent } from '../../models/action.types';
+import { ProductType } from '../../models/booking.types';
+import * as i0 from "@angular/core";
+export declare class SbdActionDialogComponent {
+    private bookingService;
+    private toast;
+    visible: import("@angular/core").InputSignal<boolean>;
+    bookingId: import("@angular/core").InputSignal<string>;
+    product: import("@angular/core").InputSignal<ProductType>;
+    actions: import("@angular/core").InputSignal<ActionConfig[]>;
+    initialKey: import("@angular/core").InputSignal<string>;
+    preloadedData: import("@angular/core").InputSignal<any>;
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    selectedAction: import("@angular/core").WritableSignal<ActionConfig>;
+    actionStatus: import("@angular/core").WritableSignal<"error" | "idle" | "loading" | "success">;
+    actionData: import("@angular/core").WritableSignal<unknown>;
+    elapsedMs: import("@angular/core").WritableSignal<number>;
+    copying: import("@angular/core").WritableSignal<boolean>;
+    resultContent: import("@angular/core").Signal<ResultContent>;
+    constructor();
+    copyResult(mode: 'en' | 'ar' | 'both'): void;
+    private buildBilingualText;
+    onActionSelect(action: ActionConfig | null): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdActionDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdActionDialogComponent, "app-sbd-action-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "initialKey": { "alias": "initialKey"; "required": false; "isSignal": true; }; "preloadedData": { "alias": "preloadedData"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}

package/lib/components/action-grid/action-grid.component.d.ts

@@ -0,0 +1,10 @@
+import { ActionConfig } from '../../models/action.types';
+import * as i0 from "@angular/core";
+export declare class SbdActionGridComponent {
+    actions: import("@angular/core").InputSignal<ActionConfig[]>;
+    activeKey: import("@angular/core").InputSignal<string>;
+    loadingKey: import("@angular/core").InputSignal<string>;
+    actionSelected: import("@angular/core").OutputEmitterRef<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdActionGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdActionGridComponent, "app-sbd-action-grid", never, { "actions": { "alias": "actions"; "required": true; "isSignal": true; }; "activeKey": { "alias": "activeKey"; "required": false; "isSignal": true; }; "loadingKey": { "alias": "loadingKey"; "required": false; "isSignal": true; }; }, { "actionSelected": "actionSelected"; }, never, never, true, never>;
+}

package/lib/components/add-note-dialog/add-note-dialog.component.d.ts

@@ -0,0 +1,25 @@
+import { ProductType } from '../../models/booking.types';
+import * as i0 from "@angular/core";
+type NoteAction = 'GENERAL' | 'FEEDBACK' | 'REMARK';
+export declare class SbdAddNoteDialogComponent {
+    private bookingService;
+    private toast;
+    visible: import("@angular/core").InputSignal<boolean>;
+    bookingId: import("@angular/core").InputSignal<string>;
+    product: import("@angular/core").InputSignal<ProductType>;
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    message: import("@angular/core").WritableSignal<string>;
+    action: import("@angular/core").WritableSignal<NoteAction>;
+    submitting: import("@angular/core").WritableSignal<boolean>;
+    readonly actionOptions: {
+        label: string;
+        value: NoteAction;
+        icon: string;
+    }[];
+    constructor();
+    submit(): void;
+    private reset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdAddNoteDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdAddNoteDialogComponent, "app-sbd-add-note-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+export {};

package/lib/components/booking-input/booking-input.component.d.ts

@@ -0,0 +1,23 @@
+import { ProductType } from '../../models/booking.types';
+import * as i0 from "@angular/core";
+interface ProductOption {
+    label: string;
+    value: ProductType;
+    disabled?: boolean;
+}
+export declare class SbdBookingInputComponent {
+    loading: import("@angular/core").InputSignal<boolean>;
+    product: import("@angular/core").ModelSignal<ProductType>;
+    bookingId: import("@angular/core").ModelSignal<string>;
+    lookup: import("@angular/core").OutputEmitterRef<void>;
+    readonly productOptions: ProductOption[];
+    readonly demoIds: {
+        label: string;
+        value: string;
+    }[];
+    fillDemo(id: string): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdBookingInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdBookingInputComponent, "app-sbd-booking-input", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": false; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; }, { "product": "productChange"; "bookingId": "bookingIdChange"; "lookup": "lookup"; }, never, never, true, never>;
+}
+export {};

package/lib/components/cancel-dialog/cancel-dialog.component.d.ts

@@ -0,0 +1,395 @@
+import * as i0 from "@angular/core";
+type LegSelection = 'onward' | 'return' | 'both';
+type RefundData = any;
+export declare class SbdCancelDialogComponent {
+    private bookingService;
+    private toast;
+    visible: import("@angular/core").InputSignal<boolean>;
+    bookingId: import("@angular/core").InputSignal<string>;
+    product: import("@angular/core").InputSignal<"flight" | "hotel">;
+    pnrInfo: import("@angular/core").InputSignal<{
+        pnr?: string;
+        LegDirectionality?: string;
+    }[]>;
+    /** Same `booking_info` payload the dashboard already fetches (getBooking(..., 'booking_info')) — reused here to render real route/time details on the select-leg cards, instead of a second API call. */
+    bookingInfo: import("@angular/core").InputSignal<any>;
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    confirmed: import("@angular/core").OutputEmitterRef<LegSelection>;
+    /** Per-leg route/time details, mirroring app-sbd-flight-itinerary-card's mapping of booking_info.leg_info. */
+    itineraryLegs: import("@angular/core").Signal<any>;
+    /**
+     * The return leg is matched by an explicit 'Return' direction; the onward
+     * leg is whatever's left (some bookings don't tag the outbound leg with an
+     * explicit 'Departure' value), falling back to the first entry.
+     */
+    itineraryLeg(kind: 'onward' | 'return'): any;
+    fmtTime(dt: string): string;
+    fmtShortDate(dt: string): string;
+    fmtMins(mins: number | null): string;
+    refundData: import("@angular/core").WritableSignal<any>;
+    cancelResult: import("@angular/core").WritableSignal<any>;
+    loading: import("@angular/core").WritableSignal<boolean>;
+    cancelling: import("@angular/core").WritableSignal<boolean>;
+    confirming: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * 'select-leg' shown once the refund preview resolves, for round-trip
+     * bookings the backend hasn't already restricted to a single leg — mirrors
+     * almatar-b2c's select-leg screen. Skipped straight to 'details' otherwise.
+     */
+    step: import("@angular/core").WritableSignal<"loading" | "select-leg" | "details">;
+    /** Per-leg inclusion (checkbox) and expand/collapse state — round-trip only. */
+    onwardChecked: import("@angular/core").WritableSignal<boolean>;
+    returnChecked: import("@angular/core").WritableSignal<boolean>;
+    onwardExpanded: import("@angular/core").WritableSignal<boolean>;
+    returnExpanded: import("@angular/core").WritableSignal<boolean>;
+    selectedSource: import("@angular/core").WritableSignal<string>;
+    cancelHint: import("@angular/core").WritableSignal<string>;
+    paidSummaryExpanded: import("@angular/core").WritableSignal<boolean>;
+    preferredRefundMethod: import("@angular/core").WritableSignal<"wallet" | "originalPaymentMethod" | "split">;
+    private readonly CANCEL_HINTS;
+    private hintTimer;
+    hasOnward: import("@angular/core").Signal<boolean>;
+    hasReturn: import("@angular/core").Signal<boolean>;
+    isRoundTrip: import("@angular/core").Signal<boolean>;
+    /** Which leg(s) the backend allows cancelling, from the refund preview response. */
+    legDirectionality: import("@angular/core").Signal<"ONWARD" | "RETURN" | "BOTH">;
+    /**
+     * Whether to render the round-trip "two leg cards" UI. Only when the
+     * backend explicitly allows cancelling both legs — otherwise (ONWARD-only /
+     * RETURN-only) show a single card for that leg, same as a one-way booking.
+     */
+    showRoundTripLegCards: import("@angular/core").Signal<boolean>;
+    /** Derived from the per-leg checkboxes — 'both' unless exactly one is unchecked. */
+    selectedLeg: import("@angular/core").Signal<LegSelection>;
+    activeSourceBreakdown: import("@angular/core").Signal<Record<string, any>>;
+    availableSources: import("@angular/core").Signal<string[]>;
+    currentData: import("@angular/core").Signal<any>;
+    adjustedData: import("@angular/core").Signal<any>;
+    private applySourceOverride;
+    /**
+     * When exactly one of the four refund-destination fields (wallet / card /
+     * credit / loyalty) is non-zero, the backend has occasionally sent that
+     * field as a pre-deduction value that disagrees with the declared total
+     * (e.g. wallet = total + cancellation fee) — there's no ambiguity about
+     * *where* the money goes, only a stale number in that one field, so trust
+     * the declared total and correct the sole destination to match rather
+     * than surfacing a false discrepancy.
+     */
+    private reconcileSoleDestination;
+    /**
+     * Per-leg refund view (independent of the checkbox inclusion state) — used
+     * to render both legs' own breakdown cards simultaneously.
+     */
+    legAdjustedData(legType: 'onward' | 'return'): RefundData | null;
+    /** Deduction rows for a single leg's card. */
+    legDeductions(legType: 'onward' | 'return'): {
+        label: string;
+        value: number;
+        badge: string;
+    }[];
+    /**
+     * Refundable pool ("Fare") for a leg — that leg's own paid amount
+     * (`totalSupplierBookingAmount`). `totalRefundAmount + totalCancellationFee`
+     * isn't reliable: `totalCancellationFee` doesn't include every deduction
+     * (e.g. `handlingFee`), which produced a Fare that didn't reconcile with
+     * Total Refund + the shown deductions.
+     */
+    legRefundPool(legType: 'onward' | 'return'): number;
+    /** True once a leg's own departure time has passed. */
+    legAlreadyFlown(legType: 'onward' | 'return'): boolean;
+    /**
+     * Non-CrossSeller airlines require the whole round-trip/multicity
+     * itinerary to be cancelled together — a leg can't be excluded on its own
+     * unless it has already flown (which naturally degrades to a one-way
+     * cancellation of just the remaining leg). Set when an uncheck attempt was
+     * blocked for this reason, so the leg's checkbox can be frozen (locked)
+     * and the note shown.
+     */
+    forcedLegType: import("@angular/core").WritableSignal<"return" | "onward">;
+    /**
+     * Toggle a leg's inclusion. A non-refundable leg can't be checked, and the
+     * last checked leg can't be unchecked. Used on both the select-leg screen
+     * and the round-trip leg cards.
+     */
+    toggleLeg(legType: 'onward' | 'return'): void;
+    /** Toggle a leg card's expanded/collapsed state. */
+    toggleLegExpanded(legType: 'onward' | 'return'): void;
+    sourceNonRefundableHint: import("@angular/core").Signal<string>;
+    deductions: import("@angular/core").Signal<{
+        label: string;
+        value: number;
+        badge: string;
+    }[]>;
+    /**
+     * Itemized refundable rows ("Fare" + named refundable add-ons/ancillaries)
+     * from `refundBreakdown.refundable`. Empty when the backend hasn't sent a
+     * breakdown yet — callers fall back to the single aggregate Fare row.
+     */
+    refundableBreakdownRows(d: any): {
+        label: string;
+        value: number;
+    }[];
+    /** Named refundable add-ons/ancillaries only (excludes Fare) — drives the "processed separately" note. */
+    private refundableAddonItems;
+    /** Whether to show the "add-on refund processed separately by Customer Service" note. */
+    hasRefundableAddonNote(d: any): boolean;
+    /**
+     * Deduction rows for the "Not Refunded" section. When an itemized
+     * breakdown is present, its named add-ons/ancillaries replace the
+     * aggregate `totalAncillaryRefundAmount`/`totalGiftAmount` rows (same
+     * money, named instead of lumped); the other generic rows (cancellation
+     * fee, handling fee, service charge) are unaffected.
+     */
+    private deductionRows;
+    refunds: import("@angular/core").Signal<{
+        label: string;
+        value: number;
+    }[]>;
+    creditShellNote: import("@angular/core").Signal<string>;
+    private resolvePnr;
+    /**
+     * Booking includes a Golden Guarantee gift ("Cancel for any reason") —
+     * overrides all credit-shell handling below, since a Golden Guarantee
+     * cancellation always refunds 100% through the standard payment method
+     * rather than the airline credit shell. May be carried on either the
+     * preview (`refundData`) or the confirm (`cancelResult`) response — both
+     * share the same shape, and either one may set it independently of the
+     * other.
+     */
+    hasGoldenGuaranteeGift: import("@angular/core").Signal<boolean>;
+    isCreditShell: import("@angular/core").Signal<boolean>;
+    /**
+     * Refundable ancillaries (baggage, seats, …) that carry their own
+     * `isCreditShell` flag, independent of the booking-level flag — rendered
+     * as individual cards on the credit-shell refund-method screen so each
+     * one can show either the credit-shell card style or the normal wallet
+     * card style (both include the same nested credit-shell note when true).
+     */
+    creditShellAncillaryItems: import("@angular/core").Signal<any[]>;
+    creditShellSupplierName: import("@angular/core").Signal<string>;
+    refundTypeLabel: import("@angular/core").Signal<string>;
+    currency: import("@angular/core").Signal<string>;
+    discrepancyNote: import("@angular/core").Signal<string>;
+    /** Real per-booking CrossSeller flag from the refund preview — CrossSeller suppliers allow cancelling either leg independently. */
+    isCrossSeller: import("@angular/core").Signal<boolean>;
+    onwardRefundable: import("@angular/core").Signal<boolean>;
+    returnRefundable: import("@angular/core").Signal<boolean>;
+    isMixed: import("@angular/core").Signal<boolean>;
+    /** Both legs present and BOTH non-refundable — nothing can be refunded for this booking. */
+    allLegsNonRefundable: import("@angular/core").Signal<boolean>;
+    mixedHint: import("@angular/core").Signal<string>;
+    giftHint: import("@angular/core").Signal<string>;
+    selectionHint: import("@angular/core").Signal<string>;
+    confirmDeductions: import("@angular/core").Signal<{
+        label: string;
+        value: number;
+    }[]>;
+    confirmRefunds: import("@angular/core").Signal<{
+        key: string;
+        label: string;
+        value: number;
+        subRows?: {
+            label: string;
+            value: number;
+        }[];
+        hasLoyaltyNote?: boolean;
+    }[]>;
+    /** Rows that land in the wallet — plain wallet, wallet+loyalty combined, or loyalty-only — share the wallet icon/layout on the result screen. */
+    isWalletDestinationRow(r: {
+        key: string;
+    }): boolean;
+    /**
+     * The result screen's "issued as an Airline Credit Shell" note. Golden
+     * Guarantee overrides this to '' — the confirmation renders like a
+     * standard Sabre/Amadeus refund instead (see `confirmRefunds`' folding
+     * of any credit-shell amount into the normal payment-method row).
+     */
+    confirmCreditShellNote: import("@angular/core").Signal<string>;
+    fmtResult(value: number): string;
+    /**
+     * The customer-facing total (ceiled) must match the pre-rounding total the
+     * refund is actually computed from — i.e. `totalRefundAmount` must be
+     * `totalRefundAmountBeforeCeil` rounded up to a whole currency unit (e.g.
+     * 1454.5 → 1455). A mismatch here means the supplier response itself is
+     * internally inconsistent and must block confirmation.
+     */
+    refundReconciles: import("@angular/core").Signal<boolean>;
+    canConfirm: import("@angular/core").Signal<boolean>;
+    /**
+     * `totalLoyaltyPoints` is normally the forfeited-at-booking points count
+     * (no refund destination of its own). But when the backend never
+     * populates `totalLoyaltyPointsRefundAmount` for a `loyaltyPaymentType`
+     * booking, this is the only signal that a loyalty program was involved,
+     * so it doubles as a split-refund row (alongside Card/Wallet) rather than
+     * disappearing from the refund breakdown entirely. Always shown as its
+     * own row under the program name (e.g. "Wala") — never merged into the
+     * generic Wallet row, even when `walletRefundAmount` is also non-zero.
+     */
+    private forfeitedLoyaltyPointsFallback;
+    /**
+     * Some `/confirm` responses for a single-leg (non-cross-seller) booking
+     * put `walletRefundAmount`/`totalLoyaltyPoints` on the wrong side at the
+     * root — e.g. root reads `walletRefundAmount: 40, totalLoyaltyPoints: 0`
+     * while the single leg (which should mirror root exactly here) reads
+     * `walletRefundAmount: 0, totalLoyaltyPoints: 40`. Detected narrowly: root
+     * shows no forfeited loyalty despite `loyaltyPaymentType` being set, the
+     * root wallet amount exactly equals the leg's loyalty points, and the
+     * leg's own wallet amount disagrees — in that specific case the leg's
+     * values are trusted instead, since with only one leg they're unambiguous.
+     *
+     * A second, more common shape: root doesn't swap at all, it folds the
+     * points straight into `walletRefundAmount` as one opaque lump sum (e.g.
+     * root wallet 340 = the leg's own cash wallet 300 + the leg's forfeited
+     * loyalty points 40). Split that back into the two parts the leg already
+     * tells us about too, so the result screen can show a combined wallet card
+     * with the program named instead of one unexplained total.
+     */
+    private correctedConfirmWalletAndLoyalty;
+    /** How many of {wallet, card, loyalty} the refund is actually split across. */
+    private splitPartsCount;
+    /**
+     * A portion of the refund is forced to the wallet (e.g. loyalty points used)
+     * — in that case offer a "Split Refund" option instead of a pure
+     * original-payment-method option, since the whole amount can't go to card.
+     */
+    hasSplitRefund: import("@angular/core").Signal<boolean>;
+    /**
+     * Wallet covers the whole refund (no card or loyalty portion at all) — show
+     * the wallet option alone rather than a "split" with empty other sides.
+     */
+    isWalletOnlyRefund: import("@angular/core").Signal<boolean>;
+    /**
+     * The entire refund is forfeited loyalty points (e.g. Wala) landing back as
+     * wallet balance — no cash-wallet, card, credit or real
+     * loyalty-points-refund portion at all. Without this the picker falls
+     * through to the "Original Payment Method" card and mislabels the
+     * destination as the original gateway (e.g. "Tabby"), even though
+     * `totalCardRefundAmount` is 0 and nothing goes back to that card.
+     */
+    isLoyaltyOnlyRefund: import("@angular/core").Signal<boolean>;
+    /** A real cash-wallet portion is part of the refund (distinct from forfeited loyalty points landing in the wallet). */
+    hasCashWalletRefund: import("@angular/core").Signal<boolean>;
+    /**
+     * Wallet card's title — normally "Almatar Wallet", but the loyalty program
+     * name (Wala, Qitaf, …) when the whole refund is that program's forfeited
+     * balance landing back in the wallet.
+     */
+    walletCardLabel: import("@angular/core").Signal<string>;
+    /**
+     * Part of the refund came from converting external loyalty points into
+     * wallet funds — surfaced as a note under the wallet destination so the
+     * agent knows those points land as permanent wallet balance, not cash.
+     */
+    hasLoyaltyPointsRefund: import("@angular/core").Signal<boolean>;
+    /**
+     * The booking is refundable but nets to 0.00 after deductions — a
+     * dedicated NIL Refund state, distinct from "not refundable": no refund
+     * method to choose between, just confirmation that nothing is owed back.
+     */
+    isNilRefund: import("@angular/core").Signal<boolean>;
+    /** Same as `isNilRefund`, scoped to the confirmed cancellation result — drives the result screen's title. */
+    confirmIsNilRefund: import("@angular/core").Signal<boolean>;
+    /** Whether the customer may send the whole refund to their Almatar Wallet. */
+    isFullWalletRefundAllowed: import("@angular/core").Signal<boolean>;
+    /** Whether the customer paid via an installment gateway (Tamara, Tabby, …). */
+    isInstallmentMethod: import("@angular/core").Signal<boolean>;
+    /** Whether the customer paid via a loyalty-program gateway (Al Rajhi Mokafaa, …). */
+    isLoyaltyMethod: import("@angular/core").Signal<boolean>;
+    /** Any gateway that refunds somewhere other than a plain card — used for the wallet-style icon. */
+    isSpecialGatewayMethod: import("@angular/core").Signal<boolean>;
+    /**
+     * Card-refund settlement-timeline badge — Tabby and Tamara each have their
+     * own processing window, distinct from a plain card's generic bank policy.
+     */
+    cardBadgeText: import("@angular/core").Signal<"From 5-7 business days" | "Up to 10 business days" | "Loyalty Program Policy" | "Up to 15 business days, bank policy">;
+    /** Same as `cardBadgeText`, scoped to the confirmed cancellation result. */
+    confirmCardBadgeText: import("@angular/core").Signal<"From 5-7 business days" | "Up to 10 business days" | "Loyalty Program Policy" | "Up to 15 business days, bank policy">;
+    /**
+     * Per-method breakdown of the "Total paid" amount. The backend doesn't
+     * (yet) expose a dedicated original-payment breakdown, so the known
+     * refund-destination fields (card / wallet / loyalty) are used as a proxy
+     * for how the booking was originally paid, and whatever's left over after
+     * those (e.g. a non-refundable leg/fee that never shows up in any refund
+     * field) is folded into the primary payment method — so the rows always
+     * add up to the full `originalAmount` shown above them, instead of only
+     * covering the refundable portion.
+     */
+    paidBreakdownRows: import("@angular/core").Signal<{
+        label: string;
+        value: number;
+    }[]>;
+    /** The "Total paid" row always expands — there's always at least one method to show. */
+    hasPaidBreakdown: import("@angular/core").Signal<boolean>;
+    togglePaidSummary(): void;
+    /**
+     * The backend has sent `paymentMethodCustomerUsed` as both a short code
+     * (`"CH"`) and a full gateway name (`"Card"`) at different times — match
+     * either, case-insensitively, against the known codes/labels rather than
+     * assuming one format.
+     */
+    private normalizeGatewayCode;
+    /**
+     * Display label for `paymentMethodCustomerUsed`, or '' if unknown/internal.
+     * Never surfaces an internal processor name (e.g. Hyperpay) to the agent —
+     * callers fall back to a generic "Original Payment Method" label whenever
+     * this returns ''.
+     */
+    customerPaymentLabel: import("@angular/core").Signal<string>;
+    /** Whether the confirmed cancellation's card refund settles via Mada. */
+    isMadaMethod: import("@angular/core").Signal<boolean>;
+    /**
+     * Label for the standalone "Original Payment Method" option card (shown
+     * when the whole refund goes to one destination). Mada wins over
+     * everything else, reading "Mada Card" instead of the generic gateway
+     * name or the "Original Payment Method" fallback.
+     */
+    originalPaymentLabel: import("@angular/core").Signal<string>;
+    /** Same as `isMadaMethod`, scoped to the confirmed cancellation result. */
+    confirmIsMadaMethod: import("@angular/core").Signal<boolean>;
+    /**
+     * Split-refund destination rows — up to four: Almatar Wallet (generic
+     * label), the original payment method (card/installment gateway), a
+     * separate loyalty-points-refund row when the backend sends one, and a
+     * dedicated loyalty-program row (Wala, Qitaf, …) for forfeited points
+     * (`forfeitedLoyaltyPointsFallback`) — kept distinct from the Wallet row
+     * even when both are non-zero.
+     */
+    splitRefundRows: import("@angular/core").Signal<{
+        label: string;
+        value: number;
+        instant: boolean;
+        isLoyalty: boolean;
+        badgeText: string;
+        isMada?: boolean;
+    }[]>;
+    /**
+     * Wallet-row label for a loyalty-program redemption — `loyaltyPaymentType`
+     * (e.g. Wala, Qitaf) names the program that redeemed into the wallet
+     * balance and applies regardless of `paymentMethodCustomerUsed`; the
+     * backend can report an unrelated original payment gateway (e.g. Tabby)
+     * alongside a wallet portion that's actually a loyalty redemption.
+     */
+    walletOrLoyaltyLabel(d: any): string;
+    constructor();
+    private loadRefund;
+    /**
+     * Both legs in play — sum each leg's own figures instead of trusting root
+     * (root isn't reliably scoped to the picked alternatives, e.g. rounding
+     * can drift between leg totals and the combined root total).
+     */
+    private buildCombinedLegData;
+    /** Combine two legs' itemized breakdowns for the "both legs" combined view. */
+    private mergeBreakdowns;
+    private buildLegData;
+    startHints(): void;
+    stopHints(): void;
+    fmt(value: number, currency?: string): string;
+    fmtNum(value: number): string;
+    fmtNeg(value: number, currency?: string): string;
+    fmtNegResult(value: number): string;
+    requestCancel(): void;
+    confirm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdCancelDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdCancelDialogComponent, "app-sbd-cancel-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": false; "isSignal": true; }; "pnrInfo": { "alias": "pnrInfo"; "required": false; "isSignal": true; }; "bookingInfo": { "alias": "bookingInfo"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "confirmed": "confirmed"; }, never, never, true, never>;
+}
+export {};

package/lib/components/data-search/data-search.component.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+type EntryType = 'date' | 'duration' | 'bool' | 'number' | 'text';
+interface FlatEntry {
+    path: string;
+    key: string;
+    rawValue: string;
+    displayValue: string;
+    type: EntryType;
+}
+export declare class SbdDataSearchComponent {
+    data: import("@angular/core").InputSignal<any>;
+    query: import("@angular/core").WritableSignal<string>;
+    private allEntries;
+    results: import("@angular/core").Signal<FlatEntry[]>;
+    totalCount: import("@angular/core").Signal<number>;
+    private flatten;
+    private formatEntry;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdDataSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdDataSearchComponent, "app-sbd-data-search", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/components/flight-itinerary-card/flight-itinerary-card.component.d.ts

@@ -0,0 +1,17 @@
+import { ProductType } from '../../models/booking.types';
+import * as i0 from "@angular/core";
+export declare class SbdFlightItineraryCardComponent {
+    data: import("@angular/core").InputSignal<any>;
+    product: import("@angular/core").InputSignal<ProductType>;
+    verified: import("@angular/core").InputSignal<boolean>;
+    private bi;
+    legs: import("@angular/core").Signal<any>;
+    passengers: import("@angular/core").Signal<any[]>;
+    payment: import("@angular/core").Signal<any>;
+    readonly typeLabel: Record<string, string>;
+    fmtTime(dt: string): string;
+    fmtShortDate(dt: string): string;
+    fmtMins(mins: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdFlightItineraryCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdFlightItineraryCardComponent, "app-sbd-flight-itinerary-card", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "product": { "alias": "product"; "required": true; "isSignal": true; }; "verified": { "alias": "verified"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/result-panel/result-panel.component.d.ts

@@ -0,0 +1,14 @@
+import { ResultContent } from '../../models/action.types';
+import * as i0 from "@angular/core";
+export declare class SbdResultPanelComponent {
+    private toast;
+    actionLabel: import("@angular/core").InputSignal<string>;
+    elapsedMs: import("@angular/core").InputSignal<number>;
+    status: import("@angular/core").InputSignal<"error" | "idle" | "loading" | "success">;
+    result: import("@angular/core").InputSignal<ResultContent>;
+    feedbackGiven: import("@angular/core").OutputEmitterRef<"up" | "down">;
+    get elapsedSeconds(): string;
+    copy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdResultPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdResultPanelComponent, "app-sbd-result-panel", never, { "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; "elapsedMs": { "alias": "elapsedMs"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "result": { "alias": "result"; "required": false; "isSignal": true; }; }, { "feedbackGiven": "feedbackGiven"; }, never, never, true, never>;
+}

package/lib/components/workflow-actions/workflow-actions.component.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class SbdWorkflowActionsComponent {
+    bookingId: import("@angular/core").InputSignal<string>;
+    cancelBooking: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdWorkflowActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdWorkflowActionsComponent, "app-sbd-workflow-actions", never, { "bookingId": { "alias": "bookingId"; "required": true; "isSignal": true; }; }, { "cancelBooking": "cancelBooking"; }, never, never, true, never>;
+}

package/lib/config/dashboard.config.d.ts

@@ -0,0 +1,15 @@
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+/**
+ * Host-app configuration for the Smart Booking Dashboard.
+ * Every field is optional; the defaults match the Almatar backoffice.
+ */
+export interface SbdConfig {
+    /** Base URL of the backend API. Default: '/api' */
+    apiBase: string;
+    /** Value of the `platform` header sent with FCR requests. Default: 'BO' */
+    platform: string;
+}
+export declare const SBD_DEFAULT_CONFIG: SbdConfig;
+export declare const SBD_CONFIG: InjectionToken<SbdConfig>;
+/** Optional: call in the host app's providers to override the defaults. */
+export declare function provideSmartBookingDashboard(config?: Partial<SbdConfig>): EnvironmentProviders;

package/lib/config/flight-actions.config.d.ts

@@ -0,0 +1,2 @@
+import { ActionConfig } from '../models/action.types';
+export declare const FLIGHT_ACTIONS: ActionConfig[];

package/lib/config/hotel-actions.config.d.ts

@@ -0,0 +1,2 @@
+import { ActionConfig } from '../models/action.types';
+export declare const HOTEL_ACTIONS: ActionConfig[];

package/lib/config/labels.ar.d.ts

@@ -0,0 +1,2 @@
+export declare const AR_LABELS: Record<string, string>;
+export declare const AR_SECTION_TITLES: Record<string, string>;

package/lib/models/action.types.d.ts

@@ -0,0 +1,34 @@
+export interface ResultPoint {
+    label: string;
+    value: string;
+}
+export interface ResultCallout {
+    type: 'info' | 'warning' | 'tip';
+    message: string;
+}
+export interface ResultRow {
+    label: string;
+    value: string;
+    valueClass?: 'positive' | 'negative' | 'neutral';
+}
+export interface ResultSection {
+    title: string;
+    rows: ResultRow[];
+}
+export interface ResultContent {
+    title: string;
+    subtitle?: string;
+    points?: ResultPoint[];
+    sections?: ResultSection[];
+    callout?: ResultCallout;
+}
+export interface ActionConfig {
+    key: string;
+    type: 'flight' | 'hotel';
+    label: string;
+    subtitle: string;
+    icon: string;
+    apiField: string | string[];
+    hidden?: boolean;
+    formatter: (data: any) => ResultContent;
+}

package/lib/models/booking.types.d.ts

@@ -0,0 +1,6 @@
+export type ProductType = 'flight' | 'hotel';
+export type BookingStatus = 'idle' | 'loading' | 'success' | 'error';
+export interface BookingResponse {
+    data: any;
+    elapsedMs: number;
+}