@almatar/smart-booking-dashboard 0.0.1 → 0.0.2-alpha.3

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

@@ -12,7 +12,7 @@ export declare class SbdActionDialogComponent {
     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">;
+    actionStatus: import("@angular/core").WritableSignal<"error" | "success" | "idle" | "loading">;
     actionData: import("@angular/core").WritableSignal<unknown>;
     elapsedMs: import("@angular/core").WritableSignal<number>;
     copying: import("@angular/core").WritableSignal<boolean>;

package/lib/components/almatar-aside/aside-back-button.service.d.ts

@@ -0,0 +1,11 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AsideBackButtonService {
+    showBackButton$: BehaviorSubject<boolean>;
+    backClicked$: Subject<void>;
+    show(): void;
+    hide(): void;
+    emitBack(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsideBackButtonService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsideBackButtonService>;
+}

package/lib/components/almatar-aside/aside.component.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter, OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { SharedService } from '../../shared/services/shared.service';
+import { AsideBackButtonService } from './aside-back-button.service';
+import * as i0 from "@angular/core";
+export declare class AsideComponent implements OnInit, OnDestroy {
+    private shared;
+    private document;
+    private backButtonService;
+    asideTitle: string;
+    showHeader: boolean;
+    headerTemplate: TemplateRef<any>;
+    /**
+     * Opt-in white header (instead of the default purple/lavender) — only
+     * takes effect on the Almatar brand, so other tenants/brands sharing this
+     * component keep their existing header regardless of this input.
+     */
+    whiteHeader: boolean;
+    showAside: boolean;
+    /** Opt-in desktop width override (e.g. `'600px'`) — defaults to 490px, or 580px with the white header. */
+    width: string;
+    modal: boolean;
+    closable: boolean;
+    transitionOptions: string;
+    /**
+     * When true, the dialog's own close (the X, Esc) does NOT hide the aside; it only emits
+     * {@link closeRequested}, so the host can ask for confirmation and close the aside itself.
+     */
+    interceptClose: boolean;
+    onClose: EventEmitter<any>;
+    closeRequested: EventEmitter<void>;
+    isInAppView: boolean;
+    selectedLang: string;
+    showBackButton: boolean;
+    get backIconClass(): string;
+    get isWhiteHeader(): boolean;
+    constructor(shared: SharedService, document: Document, backButtonService: AsideBackButtonService);
+    ngOnInit(): void;
+    /** Replaces the two-way `[(visible)]` so a host can veto the dialog's own close. */
+    onVisibleChange(visible: boolean): void;
+    onCloseModal(): void;
+    onBackIconClick(event: Event): void;
+    onDialogShow(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsideComponent, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AsideComponent, "almatar-aside", never, { "asideTitle": { "alias": "asideTitle"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "whiteHeader": { "alias": "whiteHeader"; "required": false; }; "showAside": { "alias": "showAside"; "required": false; }; "width": { "alias": "width"; "required": false; }; "modal": { "alias": "modal"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "transitionOptions": { "alias": "transitionOptions"; "required": false; }; "interceptClose": { "alias": "interceptClose"; "required": false; }; }, { "onClose": "onClose"; "closeRequested": "closeRequested"; }, never, ["*"], true, never>;
+}

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

@@ -157,6 +157,13 @@ export declare class SbdCancelDialogComponent {
      * other.
      */
     hasGoldenGuaranteeGift: import("@angular/core").Signal<boolean>;
+    /**
+     * Fallback for environments whose refund response has no `hasGoldenGuaranteeGift`
+     * flag: scan every itemized add-on/ancillary/gift the refund preview exposes
+     * (root + per-leg, refundable + non-refundable) for a golden-guarantee
+     * category/type/name match.
+     */
+    private hasGoldenGuaranteeAddOn;
     isCreditShell: import("@angular/core").Signal<boolean>;
     /**
      * Refundable ancillaries (baggage, seats, …) that carry their own

package/lib/components/hotel-cancel/almatar-hotel-auto-cancellation.component.d.ts

@@ -0,0 +1,97 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { HotelManageBookingService } from '../shared/services/hotel-manage-booking/hotel-manage-booking.service';
+import { AlmatarHotelAutoCancellationStepEnum } from './enums/almatar-hotel-auto-cancellation-step.enum';
+import { AlmatarHotelAutoCancellationService } from './services/almatar-hotel-auto-cancellation.service';
+import { IAutoCancellationProcessResponse } from './services/almatar-hotel-auto-cancellation-endpoints.service';
+import { IAlmatarHotelAutoCancellationRoom, IAlmatarHotelAutoCancellationHotelInfo, IAlmatarHotelAutoCancellationPackage } from './interfaces/i-almatar-hotel-auto-cancellation.interface';
+import { IRefundDetailsData as IFlightRefundDetailsData, RefundPreferredMethod } from '../shared/interfaces/i-flight-refund-details';
+import { IHotelBookingData } from '../../models/booking.types';
+import { ResultOverlayData } from './components/result-overlay/result-overlay.component';
+import * as i0 from "@angular/core";
+export declare class AlmatarHotelAutoCancellationComponent implements OnInit, OnDestroy {
+    private readonly hotelManageBookingService;
+    readonly autoCancellationService: AlmatarHotelAutoCancellationService;
+    HotelManageBookingService: HotelManageBookingService;
+    private readonly autoCancellationEndpointsService;
+    private readonly activatedRoute;
+    private readonly destroyRef;
+    private readonly store;
+    private readonly sharedService;
+    readonly selectedHotelBooking: import("@angular/core").InputSignal<IHotelBookingData>;
+    readonly closed: import("@angular/core").OutputEmitterRef<void>;
+    readonly cancellationSuccess: import("@angular/core").OutputEmitterRef<IAutoCancellationProcessResponse>;
+    readonly nonRefundableSubmitSuccess: import("@angular/core").OutputEmitterRef<string>;
+    readonly chatWithAgent: import("@angular/core").OutputEmitterRef<void>;
+    readonly showConfirmModal: import("@angular/core").WritableSignal<boolean>;
+    readonly showErrorModal: import("@angular/core").WritableSignal<boolean>;
+    readonly showAside: import("@angular/core").WritableSignal<boolean>;
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly isCancelling: import("@angular/core").WritableSignal<boolean>;
+    readonly hotelManageError: import("@angular/core").WritableSignal<string>;
+    readonly isNusk: import("@angular/core").WritableSignal<boolean>;
+    readonly showResultOverlay: import("@angular/core").WritableSignal<boolean>;
+    readonly resultOverlayData: import("@angular/core").WritableSignal<ResultOverlayData>;
+    readonly rooms: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationRoom[]>;
+    readonly packages: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly hotelInfo: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationHotelInfo>;
+    readonly currentCurrency: import("@angular/core").WritableSignal<any>;
+    readonly refundDetailsData: import("@angular/core").WritableSignal<IFlightRefundDetailsData>;
+    readonly selectedPackageIds: import("@angular/core").WritableSignal<string[]>;
+    readonly refundMethod: import("@angular/core").WritableSignal<RefundPreferredMethod>;
+    readonly refundResponseData: import("@angular/core").WritableSignal<any>;
+    readonly stepEnum: typeof AlmatarHotelAutoCancellationStepEnum;
+    readonly currentStep: import("@angular/core").Signal<AlmatarHotelAutoCancellationStepEnum>;
+    readonly isSingleRoom: import("@angular/core").Signal<boolean>;
+    readonly isSinglePackage: import("@angular/core").Signal<boolean>;
+    readonly bookingSuppliers: import("@angular/core").Signal<any>;
+    readonly totalAdults: import("@angular/core").Signal<any>;
+    readonly totalChildren: import("@angular/core").Signal<any>;
+    readonly totalInfants: import("@angular/core").Signal<any>;
+    readonly asideTitle: import("@angular/core").Signal<"Select Refund Method" | "Confirm Cancellation" | "Select Rooms" | "Cancel Booking Request" | "Cancel Booking">;
+    constructor();
+    get closeIconName(): string;
+    ngOnInit(): void;
+    private initCurrency;
+    ngOnDestroy(): void;
+    private initializeQueryParams;
+    private loadBookingDataFromPackages;
+    private processBookingData;
+    private mapPackagesToRooms;
+    private mapBookingToPackages;
+    private calculateNights;
+    onContinueToCancel(selectedPackages: IAlmatarHotelAutoCancellationPackage[]): void;
+    onKeepRoom(): void;
+    onSelectRefundOption(data: {
+        packageIds: string[];
+        payout: any;
+        totalRefund: number;
+        responseData: any;
+    }): void;
+    /**
+     * Determines the payment method label based on totals/payout breakdown.
+     * Returns the appropriate gateway code for proper labeling.
+     */
+    /**
+     * Determines the card/installment payment method for the card row label.
+     * Loyalty programs are handled separately by determineLoyaltyType().
+     */
+    private determinePaymentMethod;
+    /**
+     * Determines the loyalty payment type for proper labeling in split refund rows.
+     * Returns the loyalty program code (e.g., 'QITAF', 'RAJHI') if applicable.
+     */
+    private determineLoyaltyType;
+    onMethodSelected(method: RefundPreferredMethod): void;
+    onBackFromRefundMethod(): void;
+    onGoBack(): void;
+    canGoBack(): boolean;
+    confirmCancellation(): void;
+    onCloseModal(): void;
+    onNonRefundableSubmitSuccess(packageName: string): void;
+    onChatWithAgent(): void;
+    closeAllModals(): void;
+    onResultOverlayConfirm(): void;
+    onResultOverlayCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationComponent, "almatar-hotel-auto-cancellation", never, { "selectedHotelBooking": { "alias": "selectedHotelBooking"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "cancellationSuccess": "cancellationSuccess"; "nonRefundableSubmitSuccess": "nonRefundableSubmitSuccess"; "chatWithAgent": "chatWithAgent"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/almatar-hotel-auto-cancellation-refund-method/almatar-hotel-auto-cancellation-refund-method.component.d.ts

@@ -0,0 +1,25 @@
+import { IRefundDetailsData, RefundPreferredMethod } from '../../../shared/interfaces/i-flight-refund-details';
+import * as i0 from "@angular/core";
+export declare class AlmatarHotelAutoCancellationRefundMethodComponent {
+    readonly refundDetailsData: import("@angular/core").InputSignal<IRefundDetailsData>;
+    readonly currencyObj: import("@angular/core").InputSignal<any>;
+    readonly refundMethod: import("@angular/core").InputSignal<RefundPreferredMethod>;
+    readonly bookingId: import("@angular/core").InputSignal<string>;
+    readonly isCancelling: import("@angular/core").InputSignal<boolean>;
+    /** Show the selector's back arrow (off for hotel - train's cancel flow turns it on). */
+    readonly showBack: import("@angular/core").InputSignal<boolean>;
+    readonly methodSelected: import("@angular/core").OutputEmitterRef<RefundPreferredMethod>;
+    readonly backRequested: import("@angular/core").OutputEmitterRef<void>;
+    readonly confirmRequested: import("@angular/core").OutputEmitterRef<void>;
+    readonly closeModal: import("@angular/core").OutputEmitterRef<void>;
+    private animation;
+    private lottieLoaded;
+    readonly isNilRefund: import("@angular/core").Signal<boolean>;
+    constructor();
+    onMethodSelected(method: RefundPreferredMethod): void;
+    onBack(): void;
+    onConfirm(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationRefundMethodComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationRefundMethodComponent, "almatar-hotel-auto-cancellation-refund-method", never, { "refundDetailsData": { "alias": "refundDetailsData"; "required": true; "isSignal": true; }; "currencyObj": { "alias": "currencyObj"; "required": true; "isSignal": true; }; "refundMethod": { "alias": "refundMethod"; "required": true; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": true; "isSignal": true; }; "isCancelling": { "alias": "isCancelling"; "required": false; "isSignal": true; }; "showBack": { "alias": "showBack"; "required": false; "isSignal": true; }; }, { "methodSelected": "methodSelected"; "backRequested": "backRequested"; "confirmRequested": "confirmRequested"; "closeModal": "closeModal"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/almatar-hotel-auto-cancellation-refund-summary/almatar-hotel-auto-cancellation-refund-summary.component.d.ts

@@ -0,0 +1,91 @@
+import { OnInit } from '@angular/core';
+import { IAlmatarHotelAutoCancellationRoom, IAlmatarHotelAutoCancellationRefundSummary, IAlmatarHotelAutoCancellationHotelInfo, IAlmatarHotelAutoCancellationRefundPackage, IAlmatarHotelAutoCancellationRefundPackageRoom, IGift } from '../../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+export declare class AlmatarHotelAutoCancellationRefundSummaryComponent implements OnInit {
+    private readonly endpointsService;
+    private readonly autoCancellationService;
+    private readonly store;
+    private readonly sharedService;
+    private readonly destroyRef;
+    private readonly translateService;
+    private readonly hotelManageBookingsEndpointsService;
+    private readonly hotelManageBookingService;
+    constructor();
+    readonly baseCurrencyCode: import("@angular/core").WritableSignal<string>;
+    readonly currentCurrency: import("@angular/core").WritableSignal<any>;
+    readonly paymentMethod: import("@angular/core").WritableSignal<any>;
+    readonly currentLang: import("@angular/core").WritableSignal<string>;
+    readonly selectedRooms: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationRoom[]>;
+    readonly bookingId: import("@angular/core").InputSignal<string | number>;
+    readonly hotelId: import("@angular/core").InputSignal<string | number>;
+    readonly hotelInfo: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationHotelInfo>;
+    readonly selectionSkipped: import("@angular/core").InputSignal<boolean>;
+    readonly keepRoom: import("@angular/core").OutputEmitterRef<void>;
+    readonly selectRefundOption: import("@angular/core").OutputEmitterRef<{
+        packageIds: string[];
+        payout: any;
+        totalRefund: number;
+        responseData: any;
+    }>;
+    readonly closeModal: import("@angular/core").OutputEmitterRef<void>;
+    readonly isCancelLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly showConfirmModalFlag: import("@angular/core").WritableSignal<boolean>;
+    readonly showErrorModalFlag: import("@angular/core").WritableSignal<boolean>;
+    readonly hotelManageError: import("@angular/core").WritableSignal<string>;
+    backArrow: import("@angular/core").Signal<string>;
+    readonly expandedPackageIds: import("@angular/core").WritableSignal<Set<string>>;
+    readonly expandedAmountIds: import("@angular/core").WritableSignal<Set<string>>;
+    readonly isLoading: import("@angular/core").WritableSignal<boolean>;
+    readonly refundSummary: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationRefundSummary>;
+    readonly error: import("@angular/core").WritableSignal<string>;
+    readonly responseData: import("@angular/core").WritableSignal<any>;
+    readonly rooms: import("@angular/core").Signal<IAlmatarHotelAutoCancellationRoom[]>;
+    groupRoomsByName(rooms: IAlmatarHotelAutoCancellationRefundPackageRoom[]): {
+        roomName: string;
+        count: number;
+        nights?: number;
+        adults?: number;
+        children?: number;
+        basis?: string;
+    }[];
+    readonly packages: import("@angular/core").Signal<IAlmatarHotelAutoCancellationRefundPackage[]>;
+    readonly currentRefundRoomsNumber: import("@angular/core").Signal<number>;
+    readonly totalPaid: import("@angular/core").Signal<number>;
+    readonly totalRefund: import("@angular/core").Signal<number>;
+    readonly alreadyRefunded: import("@angular/core").Signal<number>;
+    readonly summaries: import("@angular/core").Signal<import("../../interfaces/i-almatar-hotel-auto-cancellation.interface").IRefundSummaryItem[]>;
+    readonly payout: import("@angular/core").Signal<import("../../interfaces/i-almatar-hotel-auto-cancellation.interface").IRefundPayout>;
+    readonly packageIds: import("@angular/core").Signal<string[]>;
+    readonly totalPackagesCount: import("@angular/core").Signal<number>;
+    readonly couponAmount: import("@angular/core").Signal<number>;
+    readonly giftsTotal: import("@angular/core").Signal<number>;
+    readonly giftsDetails: import("@angular/core").Signal<IGift[]>;
+    readonly giftsHasRefundableEntity: import("@angular/core").Signal<boolean>;
+    readonly serviceFeeAmount: import("@angular/core").Signal<number>;
+    readonly surchargeAmount: import("@angular/core").Signal<number>;
+    readonly isGoldenGift: import("@angular/core").Signal<boolean>;
+    readonly payoutNote: import("@angular/core").Signal<string>;
+    readonly previousRooms: import("@angular/core").Signal<import("../../interfaces/i-almatar-hotel-auto-cancellation.interface").IRefundPreviousRoom[]>;
+    readonly hasDeductions: import("@angular/core").Signal<boolean>;
+    ngOnInit(): void;
+    private initLanguage;
+    private initCurrency;
+    loadRefundDetails(): void;
+    private calculateLocalRefundSummary;
+    togglePackageExpand(packageId: string): void;
+    toggleAmountExpand(packageId: string): void;
+    isPackageExpanded(packageId: string): boolean;
+    isAmountExpanded(packageId: string): boolean;
+    onKeepRoom(): void;
+    onSelectRefundOption(): void;
+    onClose(): void;
+    submitData(): void;
+    onConfirmSend(): void;
+    private onShowWhatsAppAgent;
+    private onShowConfirmModal;
+    closeAllModals(): void;
+    formatDate(date: string | undefined): string;
+    private determinePaymentMethod;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationRefundSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationRefundSummaryComponent, "almatar-hotel-auto-cancellation-refund-summary", never, { "selectedRooms": { "alias": "selectedRooms"; "required": true; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "hotelId": { "alias": "hotelId"; "required": false; "isSignal": true; }; "hotelInfo": { "alias": "hotelInfo"; "required": false; "isSignal": true; }; "selectionSkipped": { "alias": "selectionSkipped"; "required": false; "isSignal": true; }; }, { "keepRoom": "keepRoom"; "selectRefundOption": "selectRefundOption"; "closeModal": "closeModal"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/almatar-hotel-auto-cancellation-select-rooms/almatar-hotel-auto-cancellation-select-rooms.component.d.ts

@@ -0,0 +1,39 @@
+import { IAlmatarHotelAutoCancellationPackage, IAlmatarHotelAutoCancellationHotelInfo } from '../../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+export declare class AlmatarHotelAutoCancellationSelectRoomsComponent {
+    private readonly sharedService;
+    private readonly endpointsService;
+    private readonly autoCancellationService;
+    private readonly destroyRef;
+    readonly packages: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly isLoadingRefund: import("@angular/core").WritableSignal<boolean>;
+    constructor();
+    readonly hotelInfo: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationHotelInfo>;
+    readonly bookingId: import("@angular/core").InputSignal<string | number>;
+    readonly hotelId: import("@angular/core").InputSignal<string | number>;
+    readonly continueToCancel: import("@angular/core").OutputEmitterRef<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly closeModal: import("@angular/core").OutputEmitterRef<void>;
+    readonly nonRefundableSubmitSuccess: import("@angular/core").OutputEmitterRef<string>;
+    readonly chatWithAgent: import("@angular/core").OutputEmitterRef<void>;
+    readonly currencyCode: import("@angular/core").InputSignal<string>;
+    readonly localPackages: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly displayPackages: import("@angular/core").Signal<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly selectedPackagesCount: import("@angular/core").Signal<number>;
+    readonly hasSelectedPackages: import("@angular/core").Signal<boolean>;
+    readonly isSinglePackage: import("@angular/core").Signal<boolean>;
+    readonly totalRoomsCount: import("@angular/core").Signal<number>;
+    readonly allPackagesNonRefundable: import("@angular/core").Signal<boolean>;
+    togglePackage(packageId: string): void;
+    onContinue(): void;
+    onClose(): void;
+    onChatWithAgent(): void;
+    onNonRefundableSubmitSuccess(packageName: string): void;
+    formatDate(date: any): {
+        day: number;
+        month: string;
+        year: number;
+        dayName: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationSelectRoomsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationSelectRoomsComponent, "almatar-hotel-auto-cancellation-select-rooms", never, { "packages": { "alias": "packages"; "required": true; "isSignal": true; }; "hotelInfo": { "alias": "hotelInfo"; "required": true; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "hotelId": { "alias": "hotelId"; "required": false; "isSignal": true; }; "currencyCode": { "alias": "currencyCode"; "required": false; "isSignal": true; }; }, { "continueToCancel": "continueToCancel"; "closeModal": "closeModal"; "nonRefundableSubmitSuccess": "nonRefundableSubmitSuccess"; "chatWithAgent": "chatWithAgent"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/almatar-hotel-auto-cancellation-select-rooms/components/almatar-hotel-auto-cancellation-non-refundable-room/almatar-hotel-auto-cancellation-non-refundable-room.component.d.ts

@@ -0,0 +1,44 @@
+import { IAlmatarHotelAutoCancellationPackage, IAlmatarHotelAutoCancellationHotelInfo, IAlmatarHotelAutoCancellationPackageRoom } from '../../../../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+interface IGroupedPackageRoom {
+    key: string;
+    bedTypeOrRoomType: string;
+    roomBasis: string;
+    count: number;
+    rooms: IAlmatarHotelAutoCancellationPackageRoom[];
+}
+export declare class AlmatarHotelAutoCancellationNonRefundableRoomComponent {
+    private readonly http;
+    private readonly destroyRef;
+    private readonly endpointsService;
+    private readonly translateService;
+    private readonly dialogService;
+    readonly package: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationPackage>;
+    readonly allPackages: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationPackage[]>;
+    readonly hotelInfo: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationHotelInfo>;
+    readonly hotelId: import("@angular/core").InputSignal<string | number>;
+    readonly currencyCode: import("@angular/core").InputSignal<string>;
+    readonly allPackagesNonRefundable: import("@angular/core").InputSignal<boolean>;
+    private readonly useLocalCancellationPolicies;
+    readonly closeModal: import("@angular/core").OutputEmitterRef<void>;
+    readonly nonRefundableSubmitSuccess: import("@angular/core").OutputEmitterRef<string>;
+    readonly uploadedFile: import("@angular/core").WritableSignal<File>;
+    readonly uploadedFileUrl: import("@angular/core").WritableSignal<string>;
+    readonly filePicked: import("@angular/core").WritableSignal<File>;
+    readonly uploadSuccess: import("@angular/core").WritableSignal<boolean>;
+    readonly uploadProgress: import("@angular/core").WritableSignal<number>;
+    readonly isUploading: import("@angular/core").WritableSignal<boolean>;
+    readonly isSubmitting: import("@angular/core").WritableSignal<boolean>;
+    readonly submitSuccess: import("@angular/core").WritableSignal<boolean>;
+    readonly submitError: import("@angular/core").WritableSignal<string>;
+    readonly groupedRooms: import("@angular/core").Signal<IGroupedPackageRoom[]>;
+    onFileSelected(event: Event): void;
+    private uploadFile;
+    onSubmitRequest(): void;
+    onRetry(): void;
+    onOpenCancellationPolicy(): void;
+    formatFileSize(bytes: number | undefined): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationNonRefundableRoomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationNonRefundableRoomComponent, "almatar-hotel-auto-cancellation-non-refundable-room", never, { "package": { "alias": "package"; "required": true; "isSignal": true; }; "allPackages": { "alias": "allPackages"; "required": false; "isSignal": true; }; "hotelInfo": { "alias": "hotelInfo"; "required": false; "isSignal": true; }; "hotelId": { "alias": "hotelId"; "required": false; "isSignal": true; }; "currencyCode": { "alias": "currencyCode"; "required": false; "isSignal": true; }; "allPackagesNonRefundable": { "alias": "allPackagesNonRefundable"; "required": false; "isSignal": true; }; }, { "closeModal": "closeModal"; "nonRefundableSubmitSuccess": "nonRefundableSubmitSuccess"; }, never, never, true, never>;
+}
+export {};

package/lib/components/hotel-cancel/components/almatar-hotel-auto-cancellation-select-rooms/components/almatar-hotel-auto-cancellation-refundable-room/almatar-hotel-auto-cancellation-refundable-room.component.d.ts

@@ -0,0 +1,19 @@
+import { IAlmatarHotelAutoCancellationPackage, IAlmatarHotelAutoCancellationPackageRoom } from '../../../../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+interface IGroupedPackageRoom {
+    key: string;
+    bedTypeOrRoomType: string;
+    roomBasis: string;
+    count: number;
+    rooms: IAlmatarHotelAutoCancellationPackageRoom[];
+}
+export declare class AlmatarHotelAutoCancellationRefundableRoomComponent {
+    readonly package: import("@angular/core").InputSignal<IAlmatarHotelAutoCancellationPackage>;
+    readonly hideCheckbox: import("@angular/core").InputSignal<boolean>;
+    readonly togglePackage: import("@angular/core").OutputEmitterRef<string>;
+    readonly groupedRooms: import("@angular/core").Signal<IGroupedPackageRoom[]>;
+    onTogglePackage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationRefundableRoomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationRefundableRoomComponent, "almatar-hotel-auto-cancellation-refundable-room", never, { "package": { "alias": "package"; "required": true; "isSignal": true; }; "hideCheckbox": { "alias": "hideCheckbox"; "required": false; "isSignal": true; }; }, { "togglePackage": "togglePackage"; }, never, never, true, never>;
+}
+export {};

package/lib/components/hotel-cancel/components/hotel-content/hotel-content.component.d.ts

@@ -0,0 +1,38 @@
+import { IHotelBookingData } from '../../../../models/booking.types';
+import * as i0 from "@angular/core";
+export declare class SbdHotelContentComponent {
+    bookingData: import("@angular/core").InputSignal<IHotelBookingData>;
+    bookingStatus: import("@angular/core").InputSignal<"error" | "success" | "idle" | "loading">;
+    bookingId: import("@angular/core").InputSignal<string>;
+    dataVerified: import("@angular/core").InputSignal<boolean>;
+    bookingNotes: import("@angular/core").InputSignal<any[]>;
+    bookingHistory: import("@angular/core").InputSignal<any[]>;
+    historyGroups: import("@angular/core").InputSignal<any[]>;
+    activeContextTab: import("@angular/core").InputSignal<"notes" | "changes">;
+    cancelBooking: import("@angular/core").OutputEmitterRef<void>;
+    addNoteRequested: import("@angular/core").OutputEmitterRef<void>;
+    contextTabChanged: import("@angular/core").OutputEmitterRef<"notes" | "changes">;
+    detailDialogVisible: import("@angular/core").WritableSignal<boolean>;
+    selectedDetail: import("@angular/core").WritableSignal<{
+        title: string;
+        data: any;
+        type: string;
+    }>;
+    fmtNoteDate(date: {
+        sec: number;
+        usec?: number;
+    }): string;
+    formatField(field: string): string;
+    fmtDate(dt: string): string;
+    onCancelBooking(): void;
+    onAddNote(): void;
+    onTabChange(tab: 'notes' | 'changes'): void;
+    formatDate(date: string | undefined): string;
+    formatPrice(price: number | undefined): string;
+    showDetailDialog(title: string, data: any, type: string): void;
+    closeDetailDialog(): void;
+    showPackagesDetail(): void;
+    formatDetailValue(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdHotelContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdHotelContentComponent, "app-sbd-hotel-content", never, { "bookingData": { "alias": "bookingData"; "required": true; "isSignal": true; }; "bookingStatus": { "alias": "bookingStatus"; "required": true; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": true; "isSignal": true; }; "dataVerified": { "alias": "dataVerified"; "required": true; "isSignal": true; }; "bookingNotes": { "alias": "bookingNotes"; "required": true; "isSignal": true; }; "bookingHistory": { "alias": "bookingHistory"; "required": true; "isSignal": true; }; "historyGroups": { "alias": "historyGroups"; "required": true; "isSignal": true; }; "activeContextTab": { "alias": "activeContextTab"; "required": true; "isSignal": true; }; }, { "cancelBooking": "cancelBooking"; "addNoteRequested": "addNoteRequested"; "contextTabChanged": "contextTabChanged"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/hotel-refund-method-selector/hotel-refund-method-selector.component.d.ts

@@ -0,0 +1,142 @@
+import { EventEmitter } from '@angular/core';
+import { CurrencySizeEnum } from '../../../../shared/components/currency-code-icon/currency-code-icon.component';
+import { ICurrency } from '../../../../shared/models';
+import { IRefundDetailsData, RefundPreferredMethod } from '../../../shared/interfaces/i-flight-refund-details';
+import * as i0 from "@angular/core";
+export interface RefundMethodSplitRow {
+    label: string;
+    value: number;
+    instant: boolean;
+    isLoyalty: boolean;
+    isMada?: boolean;
+}
+/**
+ * Hotel Refund-method selection screen ("You will get back … / Wallet / Card /
+ * Split Refund"). Takes the raw refund snapshot (`data`) as its single
+ * source of truth and derives every display/eligibility decision from it
+ * internally — which options are eligible, the split breakdown, gateway and
+ * loyalty-program label resolution — so callers don't need to replicate any
+ * of that logic themselves.
+ */
+export declare class HotelRefundMethodSelectorComponent {
+    private _data;
+    set data(value: IRefundDetailsData | null | undefined);
+    get data(): IRefundDetailsData | null | undefined;
+    /** Fallback booking id to display when `data.bookingId` isn't set yet. */
+    bookingId: string | number | null | undefined;
+    currencyObj: ICurrency | null;
+    refundMethod: RefundPreferredMethod;
+    /** Whether the header's Back button is shown at all — off by default; callers that want it opt in. */
+    showBack: boolean;
+    /** Whether the close button is shown — off by default; callers that want it opt in. */
+    readonly showCloseButton: import("@angular/core").InputSignal<boolean>;
+    /** Whether to show the loyalty points note explaining points are refunded as permanent wallet points. */
+    readonly showLoyaltyPointsNote: import("@angular/core").InputSignal<boolean>;
+    /** Left arrow — abandons the cancellation flow entirely (closes the whole manage-booking modal). */
+    closed: EventEmitter<void>;
+    /** Right ✕ — steps back to the Refund Details screen only (mirrors the native dialog close this screen's custom header replaced). */
+    backRequested: EventEmitter<void>;
+    methodSelected: EventEmitter<RefundPreferredMethod>;
+    currencySizeEnum: CurrencySizeEnum;
+    private translateService;
+    displayBookingId: import("@angular/core").Signal<string | number>;
+    totalRefundAmount: import("@angular/core").Signal<number>;
+    walletRefundAmount: import("@angular/core").Signal<number>;
+    private gatewayCode;
+    private isLoyaltyGateway;
+    /** 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>;
+    /**
+     * Whether the payment was 100% loyalty points (no card portion).
+     * Used for description/badge when loyaltyPaymentType is set but no gateway code.
+     */
+    isLoyaltyOnlyPayment: import("@angular/core").Signal<boolean>;
+    /** Whether to show loyalty-style description/badge (either loyalty gateway OR 100% loyalty payment). */
+    showAsLoyalty: import("@angular/core").Signal<boolean>;
+    /** Whether the original card was a Mada card — its refund row reads "Mada Card" instead of the generic gateway label. */
+    isMadaMethod: 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>;
+    /** Settlement-time badge — differs per installment gateway (Tamara settles slower than Tabby). */
+    paymentBadgeKey: import("@angular/core").Signal<string>;
+    /**
+     * Display label for `paymentMethodCustomerUsed`, localized. `loyaltyPaymentType`
+     * (once the backend sends it) wins when present — it names the specific
+     * loyalty program (e.g. Al Rajhi vs Qitaf) behind a gateway like STC that
+     * doesn't say which one on its own.
+     */
+    customerPaymentLabel: import("@angular/core").Signal<string>;
+    /**
+     * Label for the standalone "Original Payment Method" option card (shown
+     * when the whole refund goes to one destination — no separate loyalty
+     * row exists here, so unlike `splitRefundRows`, the loyalty program name
+     * (e.g. "Wala") is still shown when that's what was used). 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>;
+    /**
+     * "Almatar Wallet" row label — when the backend names a specific loyalty
+     * program via `loyaltyPaymentType` (e.g. Qitaf, Al Rajhi Mokafaa), that
+     * program's name replaces the generic "Almatar Wallet" label, since the
+     * amount is actually a loyalty-program redemption rather than a plain
+     * wallet balance.
+     */
+    private walletOrLoyaltyLabel;
+    walletLabel: 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
+     * customer knows those points land as permanent wallet balance, not cash.
+     */
+    hasLoyaltyPointsRefund: 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) rather than
+     * disappearing from the refund breakdown entirely.
+     */
+    private forfeitedLoyaltyPointsFallback;
+    /** 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>;
+    showWallet: import("@angular/core").Signal<boolean>;
+    showOriginal: import("@angular/core").Signal<boolean>;
+    showSplit: import("@angular/core").Signal<boolean>;
+    /**
+     * Only one refund-method card is eligible — there's nothing to choose
+     * between, so the radio button and active-selection highlight (which imply
+     * a choice) are hidden; the single card is used automatically.
+     */
+    hasSingleOption: import("@angular/core").Signal<boolean>;
+    /**
+     * Split-refund destination rows — up to three: Almatar Wallet, the
+     * original payment method (card/installment gateway), and a separate
+     * loyalty-program row (Al Rajhi Mokafaa, Qitaf, …) when the refund is
+     * actually spread across a loyalty balance *and* something else.
+     */
+    splitRefundRows: import("@angular/core").Signal<RefundMethodSplitRow[]>;
+    select(method: RefundPreferredMethod): void;
+    close(): void;
+    back(): void;
+    /** Format an amount without the currency suffix (for interpolated copy). */
+    fmtAmount(value: number | undefined): string;
+    /** Get the description for the original payment method */
+    getOriginalPaymentDescription(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotelRefundMethodSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HotelRefundMethodSelectorComponent, "almatar-hotel-refund-method-selector", never, { "data": { "alias": "data"; "required": false; }; "bookingId": { "alias": "bookingId"; "required": false; }; "currencyObj": { "alias": "currencyObj"; "required": false; }; "refundMethod": { "alias": "refundMethod"; "required": false; }; "showBack": { "alias": "showBack"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "showLoyaltyPointsNote": { "alias": "showLoyaltyPointsNote"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "backRequested": "backRequested"; "methodSelected": "methodSelected"; }, never, never, true, never>;
+}

package/lib/components/hotel-cancel/components/result-overlay/result-overlay.component.d.ts

@@ -0,0 +1,23 @@
+import * as i0 from "@angular/core";
+export type ResultType = 'success' | 'error' | 'warning';
+export interface ResultOverlayData {
+    type: ResultType;
+    title: string;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+    showCancel?: boolean;
+    icon?: string;
+}
+export declare class ResultOverlayComponent {
+    readonly data: import("@angular/core").InputSignal<ResultOverlayData>;
+    readonly show: import("@angular/core").InputSignal<boolean>;
+    readonly confirm: import("@angular/core").OutputEmitterRef<void>;
+    readonly cancel: import("@angular/core").OutputEmitterRef<void>;
+    onConfirm(): void;
+    onCancel(): void;
+    getIcon(): string;
+    getIconClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResultOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResultOverlayComponent, "app-result-overlay", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; }, { "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
+}