@almatar/smart-booking-dashboard 0.0.2-alpha.2 → 0.0.2-alpha.4

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.component.d.ts

@@ -21,7 +21,6 @@ export declare class AsideComponent implements OnInit, OnDestroy {
     modal: boolean;
     closable: boolean;
     transitionOptions: string;
-    closeIconTemplate: TemplateRef<any>;
     /**
      * 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.
@@ -43,5 +42,5 @@ export declare class AsideComponent implements OnInit, OnDestroy {
     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; }; "closeIconTemplate": { "alias": "closeIconTemplate"; "required": false; }; "interceptClose": { "alias": "interceptClose"; "required": false; }; }, { "onClose": "onClose"; "closeRequested": "closeRequested"; }, never, ["*"], true, never>;
+    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/hotel-cancel/almatar-hotel-auto-cancellation.component.d.ts

@@ -31,6 +31,8 @@ export declare class AlmatarHotelAutoCancellationComponent implements OnInit, On
     readonly isNusk: import("@angular/core").WritableSignal<boolean>;
     readonly showResultOverlay: import("@angular/core").WritableSignal<boolean>;
     readonly resultOverlayData: import("@angular/core").WritableSignal<ResultOverlayData>;
+    readonly showDetailedResultOverlay: import("@angular/core").WritableSignal<boolean>;
+    readonly cancellationApiResponse: import("@angular/core").WritableSignal<IAutoCancellationProcessResponse>;
     readonly rooms: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationRoom[]>;
     readonly packages: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationPackage[]>;
     readonly hotelInfo: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationHotelInfo>;
@@ -92,6 +94,7 @@ export declare class AlmatarHotelAutoCancellationComponent implements OnInit, On
     closeAllModals(): void;
     onResultOverlayConfirm(): void;
     onResultOverlayCancel(): void;
+    onDetailedResultOverlayDone(): 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-summary/almatar-hotel-auto-cancellation-refund-summary.component.d.ts

@@ -49,6 +49,7 @@ export declare class AlmatarHotelAutoCancellationRefundSummaryComponent implemen
         basis?: string;
     }[];
     readonly packages: import("@angular/core").Signal<IAlmatarHotelAutoCancellationRefundPackage[]>;
+    readonly allPackagesCancelled: import("@angular/core").Signal<boolean>;
     readonly currentRefundRoomsNumber: import("@angular/core").Signal<number>;
     readonly totalPaid: import("@angular/core").Signal<number>;
     readonly totalRefund: import("@angular/core").Signal<number>;

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

@@ -0,0 +1,46 @@
+import { OnInit } from '@angular/core';
+import { RefundPreferredMethod } from '../../../shared/interfaces/i-flight-refund-details';
+import { IAutoCancellationProcessResponse } from '../../services/almatar-hotel-auto-cancellation-endpoints.service';
+import * as i0 from "@angular/core";
+export interface LoyaltySubItem {
+    label: string;
+    value: number;
+}
+export interface RefundResultRow {
+    label: string;
+    value: number;
+    instant: boolean;
+    badgeKey: string;
+    isWallet?: boolean;
+    isMada?: boolean;
+    hasLoyaltyNote?: boolean;
+    isInstallment?: boolean;
+    loyaltySubItems?: LoyaltySubItem[];
+}
+export declare class AlmatarHotelAutoCancellationResultOverlayComponent implements OnInit {
+    private readonly translateService;
+    private readonly store;
+    private readonly sharedService;
+    private readonly destroyRef;
+    readonly baseCurrencyCode: import("@angular/core").WritableSignal<string>;
+    readonly currentCurrency: import("@angular/core").WritableSignal<any>;
+    readonly visible: import("@angular/core").InputSignal<boolean>;
+    readonly currencyObj: import("@angular/core").InputSignal<any>;
+    readonly refundMethod: import("@angular/core").InputSignal<RefundPreferredMethod>;
+    readonly apiResponse: import("@angular/core").InputSignal<IAutoCancellationProcessResponse>;
+    readonly done: import("@angular/core").OutputEmitterRef<void>;
+    ngOnInit(): void;
+    private initCurrency;
+    readonly isNilRefund: import("@angular/core").Signal<boolean>;
+    readonly displayCurrency: import("@angular/core").Signal<any>;
+    readonly refundRows: import("@angular/core").Signal<RefundResultRow[]>;
+    private buildRowsFromApiResponse;
+    private getLoyaltyPrograms;
+    private getLoyaltyProgramLabel;
+    private getPaymentMethodLabel;
+    isWalletRow(row: RefundResultRow): boolean;
+    fmtAmount(value: number | undefined): string;
+    onDone(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationResultOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarHotelAutoCancellationResultOverlayComponent, "almatar-hotel-auto-cancellation-result-overlay", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "currencyObj": { "alias": "currencyObj"; "required": false; "isSignal": true; }; "refundMethod": { "alias": "refundMethod"; "required": false; "isSignal": true; }; "apiResponse": { "alias": "apiResponse"; "required": false; "isSignal": true; }; }, { "done": "done"; }, never, never, true, never>;
+}

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

@@ -2,13 +2,14 @@ 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" | "idle" | "loading" | "success">;
+    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">;
+    allPackagesCancelled: import("@angular/core").Signal<boolean>;
     cancelBooking: import("@angular/core").OutputEmitterRef<void>;
     addNoteRequested: import("@angular/core").OutputEmitterRef<void>;
     contextTabChanged: import("@angular/core").OutputEmitterRef<"notes" | "changes">;

package/lib/components/hotel-cancel/services/almatar-hotel-auto-cancellation-endpoints.service.d.ts

@@ -52,6 +52,7 @@ export interface IAutoCancellationProcessResponse {
 }
 export declare class AlmatarHotelAutoCancellationEndpointsService {
     private readonly api;
+    private readonly apiBase;
     private readonly route;
     private readonly hotelManageBookingService;
     private readonly _almatarBookingId;
@@ -63,6 +64,11 @@ export declare class AlmatarHotelAutoCancellationEndpointsService {
     readonly isNusukFlow: import("@angular/core").Signal<boolean>;
     constructor();
     private initializeBookingData;
+    /**
+     * Full URL of an endpoint from the enum. The enum paths start with `/api/`, which is the default `apiBase`; a host
+     * that serves the API somewhere else (Helix: its own API origin) sets `apiBase`, so that part is swapped for it.
+     */
+    resolveEndpoint(path: string): string;
     getRefundDetails(packageIds?: string[]): Observable<IRefundDetailsApiResponse>;
     mapApiResponseToRooms(data: IRefundDetailsData): IAlmatarHotelAutoCancellationRoom[];
     mapApiResponseToRefundSummary(data: IRefundDetailsData): IAlmatarHotelAutoCancellationRefundSummary;

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

@@ -0,0 +1,34 @@
+import { ReissueServiceKey } from '../../models/reissue.types';
+import { SbdReissueStore } from './reissue.store';
+import { SbdReissueUpgradeStore } from './reissue-upgrade.store';
+import * as i0 from "@angular/core";
+/**
+ * Reissue dialog shell: owns the p-dialog, the loading / error states and the footer, and swaps the step
+ * components. All state and rules live in `SbdReissueStore`; the steps only render and emit.
+ */
+export declare class SbdReissueDialogComponent {
+    protected readonly store: SbdReissueStore;
+    protected readonly upgrade: SbdReissueUpgradeStore;
+    private readonly config;
+    private readonly injector;
+    visible: import("@angular/core").InputSignal<boolean>;
+    bookingId: import("@angular/core").InputSignal<string>;
+    bookingData: import("@angular/core").InputSignal<any>;
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    /** Header title per screen, like the cancel dialog's "Select Leg to Cancel" / "Refund Method". */
+    protected readonly title: import("@angular/core").Signal<"Select Flight to Change" | "Choose New Date" | "Choose New Route" | "Select Flight to Upgrade" | "Choose New Class" | "Review Upgrade" | "Reissue Booking">;
+    /** Gray hint above the footer (cancel's "Select at least one flight to continue"), or why Search is disabled. */
+    protected readonly hint: import("@angular/core").Signal<string>;
+    constructor();
+    protected onServiceChosen(service: ReissueServiceKey): void;
+    /** Back from the options returns to "select leg" only when that step was shown (the upgrade store knows). */
+    protected onBack(): void;
+    /** The payment link expired: redo the whole reissue from the start (a new post-booking, the service list again). */
+    protected restartFlow(): void;
+    /** Redirects to the web search (new tab: the agent keeps the dashboard open next to the web flow). */
+    protected searchFlights(): Promise<void>;
+    /** The host's auth parameters for the web link; `{}` when it has none or it fails (the web then asks to log in). */
+    private redirectAuthParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueDialogComponent, "app-sbd-reissue-dialog", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "bookingId": { "alias": "bookingId"; "required": false; "isSignal": true; }; "bookingData": { "alias": "bookingData"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}

package/lib/components/reissue-dialog/reissue-upgrade.store.d.ts

@@ -0,0 +1,96 @@
+import { ReissuePaymentLink } from '../../models/reissue.types';
+import { ReissueLegRow } from './reissue.store';
+import * as i0 from "@angular/core";
+/** View models for the Upgrade Class steps. */
+export interface UpgradeOptionRow {
+    key: string;
+    name: string;
+    code: string;
+    extraLabel: string;
+    selected: boolean;
+    unavailable: boolean;
+}
+export interface UpgradeSectionRow {
+    id: string;
+    title: string;
+    current: string;
+    options: UpgradeOptionRow[];
+}
+export interface UpgradeSummaryRow {
+    title: string;
+    from: string;
+    to: string;
+    extraLabel: string;
+}
+/** What the primary button of the confirm step does. */
+export type UpgradeAction = 'book' | 'link' | 'done';
+/**
+ * Upgrade Class flow: pick the new class -> price it (choose-flight) -> confirm (book-now when nothing to pay,
+ * otherwise a backend-generated payment link). Reads the options the main store already loaded.
+ */
+export declare class SbdReissueUpgradeStore {
+    private main;
+    private api;
+    private destroyRef;
+    readonly submitting: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string>;
+    readonly priceChanged: import("@angular/core").WritableSignal<boolean>;
+    /** `book-now` succeeded (nothing to pay): the reissue is being placed with the supplier. */
+    readonly booked: import("@angular/core").WritableSignal<boolean>;
+    readonly paymentLink: import("@angular/core").WritableSignal<ReissuePaymentLink>;
+    private selected;
+    private unavailableKeys;
+    /** Legs the agent chose to upgrade (the "select leg" step; a one-way preselects its only leg). */
+    private legIds;
+    /** Options fetched for a partial leg selection; `null` = the options loaded when the dialog opened (all legs) apply. */
+    private freshOptions;
+    private legsStepSkipped;
+    constructor();
+    readonly currency: import("@angular/core").Signal<string>;
+    /** The options to show: for a partial leg selection the fresh response, otherwise the one loaded with the dialog. */
+    private options;
+    /** A leg can be upgraded only if it is online AND has upgrade options (per leg for leg scope; booking scope applies to all). */
+    private legUpgradable;
+    readonly legRows: import("@angular/core").Signal<ReissueLegRow[]>;
+    readonly anyLegUpgradable: import("@angular/core").Signal<boolean>;
+    readonly canContinueFromLegs: import("@angular/core").Signal<boolean>;
+    /** Legs the options on screen were requested for (all of them, or just the selected ones after a partial fetch). */
+    private optionLegs;
+    private rawSections;
+    readonly sections: import("@angular/core").Signal<UpgradeSectionRow[]>;
+    private picks;
+    readonly canContinue: import("@angular/core").Signal<boolean>;
+    /**
+     * Amount to pay: the sum of the picked options' additional fare (same as the web's `getTotalToPay`).
+     * choose-flight's own `price` is deliberately not used — it is not known whether it is the difference or the full fare.
+     */
+    readonly total: import("@angular/core").Signal<number>;
+    readonly totalLabel: import("@angular/core").Signal<string>;
+    readonly summary: import("@angular/core").Signal<UpgradeSummaryRow[]>;
+    readonly action: import("@angular/core").Signal<UpgradeAction>;
+    /** Nothing can be changed any more once the upgrade is placed or a link was generated. */
+    readonly locked: import("@angular/core").Signal<boolean>;
+    /**
+     * Service picked: go to "select leg", unless there is nothing to choose (one-way with its only leg upgradable),
+     * which goes straight to the options like the web.
+     */
+    start(): void;
+    toggleLeg(legId: string): void;
+    /**
+     * Select leg -> options. All legs selected: reuse the options loaded with the dialog. A subset: fetch the options
+     * again for just those legs (the earlier response covers the whole booking, so it would price the wrong legs).
+     */
+    continueFromLegs(): void;
+    /** Back from the options: to "select leg" when that step was shown, otherwise to the service list. */
+    back(): void;
+    select(sectionId: string, key: string): void;
+    /** Options -> confirm: prices the pick(s) with choose-flight (same body the web sends). */
+    continue(): void;
+    /** Confirm step primary action: place the free upgrade, or generate the payment link. */
+    confirm(): void;
+    private reset;
+    /** Booking scope: one itinerary. Leg scope: each picked leg as onwardLeg / returnLeg (by the real leg direction). */
+    private chooseBody;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueUpgradeStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SbdReissueUpgradeStore>;
+}

package/lib/components/reissue-dialog/reissue.store.d.ts

@@ -0,0 +1,124 @@
+import { ReissueAirport, ReissueLeg, ReissueServiceKey, ReissueUpgradeOptionsResponse } from '../../models/reissue.types';
+import * as i0 from "@angular/core";
+/** `legs` + `edit` serve change date / route; `upgrade-legs` + `upgrade` + `confirm` serve Upgrade Class. */
+export type ReissueStep = 'service' | 'legs' | 'edit' | 'upgrade-legs' | 'upgrade' | 'confirm';
+export type AirportSide = 'origin' | 'destination';
+export interface RouteEdit {
+    origin: ReissueAirport;
+    destination: ReissueAirport;
+}
+export type AirportOption = ReissueAirport & {
+    label: string;
+};
+/** View models: everything the templates need is computed here, so the templates call no methods. */
+export interface ReissueLegRow {
+    leg: ReissueLeg;
+    direction: string;
+    from: string;
+    to: string;
+    dateLabel: string;
+    depTime: string;
+    arrTime: string;
+    stopsLabel: string;
+    airlineLine: string;
+    /** The leg already departed ("Used Flight"): never selectable. */
+    flown: boolean;
+    available: boolean;
+    /** Why a leg cannot be picked: it already flew, it is offline (no online reissue), or it has no upgrade options. */
+    reason: 'flown' | 'offline' | 'no-options' | null;
+    selected: boolean;
+}
+export declare function buildLegRow(leg: ReissueLeg, available: boolean, selected: boolean, unavailableReason?: 'offline' | 'no-options'): ReissueLegRow;
+export interface ReissueDateRow {
+    leg: ReissueLeg;
+    title: string;
+    current: string;
+    value: string;
+    min: string;
+    max: string;
+}
+export interface ReissueRouteRow {
+    leg: ReissueLeg;
+    title: string;
+    current: string;
+    origin: ReissueAirport;
+    destination: ReissueAirport;
+}
+/**
+ * State + rules of the Reissue dialog (one instance per dialog, provided by the dialog component).
+ * The step components are presentational: they get view models from here through the dialog shell.
+ */
+export declare class SbdReissueStore {
+    private api;
+    private config;
+    readonly today: string;
+    private booking;
+    readonly step: import("@angular/core").WritableSignal<ReissueStep>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string>;
+    readonly postBookingId: import("@angular/core").WritableSignal<string>;
+    readonly service: import("@angular/core").WritableSignal<ReissueServiceKey>;
+    /** Raw upgrade-class response; `null` when not loaded / not offered. Read by `SbdReissueUpgradeStore`. */
+    readonly upgradeOptions: import("@angular/core").WritableSignal<ReissueUpgradeOptionsResponse>;
+    readonly upgradeAvailable: import("@angular/core").Signal<boolean>;
+    private availableIds;
+    /** The availability call answered (so "no leg available" is a real answer, not "still loading"). */
+    private availabilityLoaded;
+    private selectedLegIds;
+    /** The "select flight" step was skipped (one-way): Back from the edit step returns to the service list. */
+    private legsStepSkipped;
+    private dateEdits;
+    private routeEdits;
+    private searchedAirports;
+    private load$;
+    private airportTerm$;
+    constructor();
+    readonly ctx: import("@angular/core").Signal<import("../../models/reissue.types").ReissueBookingContext>;
+    readonly legs: import("@angular/core").Signal<ReissueLeg[]>;
+    private selectedSet;
+    private selectedLegs;
+    readonly legRows: import("@angular/core").Signal<ReissueLegRow[]>;
+    /** The leg came back online from the availability check. */
+    isLegOnline(legId: string): boolean;
+    /** `false` = a round trip must be upgraded as a whole (availability's `allowCustomerToSelectSingleLeg`). */
+    readonly allowSingleLegSelection: import("@angular/core").WritableSignal<boolean>;
+    readonly anyAvailable: import("@angular/core").Signal<boolean>;
+    /**
+     * No leg can be reissued online (offline, or already flown): the dialog shows this message instead of the options,
+     * like the cancel dialog does for a booking it cannot auto-cancel. `null` while loading or when any leg is available.
+     */
+    readonly blocked: import("@angular/core").Signal<{
+        title: string;
+        text: string;
+    }>;
+    readonly canContinue: import("@angular/core").Signal<boolean>;
+    /** A leg's date after the change: the new one when the agent is changing it, the original otherwise. */
+    readonly dateRows: import("@angular/core").Signal<ReissueDateRow[]>;
+    readonly routeRows: import("@angular/core").Signal<ReissueRouteRow[]>;
+    readonly airportOptions: import("@angular/core").Signal<AirportOption[]>;
+    readonly validationError: import("@angular/core").Signal<string>;
+    /** (Re)starts the dialog for a booking: clears every choice, then loads post-booking + availability. */
+    open(data: unknown, id: string): void;
+    load(): void;
+    chooseService(service: ReissueServiceKey): void;
+    toggleLeg(legId: string): void;
+    /** Legs -> edit: seed each selected leg with its current date / airports. */
+    goToEdit(): void;
+    goTo(step: ReissueStep): void;
+    back(): void;
+    setDate(legId: string, date: string): void;
+    setAirport(legId: string, side: AirportSide, airport: ReissueAirport | null): void;
+    /** Swaps a leg's origin and destination (the arrow between the two pickers). */
+    swapAirports(legId: string): void;
+    searchAirports(term: string): void;
+    /** The web search URL for the current choices, or `null` when they are not valid yet. */
+    searchUrl(): string | null;
+    private loadFlow;
+    /**
+     * The upgrade-class options (same rule as the web for listing "Upgrade Class"): skipped for a one-way whose
+     * only leg is offline; a failing call just yields `null` (option hidden) instead of blocking the dialog.
+     */
+    private offersUpgrade;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SbdReissueStore>;
+}

package/lib/components/reissue-dialog/steps/reissue-date-step/reissue-date-step.component.d.ts

@@ -0,0 +1,11 @@
+import { ReissueDateRow } from '../../reissue.store';
+import * as i0 from "@angular/core";
+export declare class SbdReissueDateStepComponent {
+    rows: import("@angular/core").InputSignal<ReissueDateRow[]>;
+    changed: import("@angular/core").OutputEmitterRef<{
+        legId: string;
+        date: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueDateStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueDateStepComponent, "app-sbd-reissue-date-step", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}

package/lib/components/reissue-dialog/steps/reissue-legs-step/reissue-legs-step.component.d.ts

@@ -0,0 +1,16 @@
+import { ReissueLegRow } from '../../reissue.store';
+import * as i0 from "@angular/core";
+/** Leg cards in the cancel dialog's "Select Leg" design: checkbox overlay, outline badge, times row. */
+export declare class SbdReissueLegsStepComponent {
+    rows: import("@angular/core").InputSignal<ReissueLegRow[]>;
+    anyAvailable: import("@angular/core").InputSignal<boolean>;
+    unavailableText: import("@angular/core").InputSignal<string>;
+    /** Extra info line, e.g. "these flights must be upgraded together". */
+    note: import("@angular/core").InputSignal<string>;
+    error: import("@angular/core").InputSignal<string>;
+    toggled: import("@angular/core").OutputEmitterRef<string>;
+    /** The note under a disabled leg. */
+    protected reasonText(reason: ReissueLegRow['reason']): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueLegsStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueLegsStepComponent, "app-sbd-reissue-legs-step", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "anyAvailable": { "alias": "anyAvailable"; "required": false; "isSignal": true; }; "unavailableText": { "alias": "unavailableText"; "required": false; "isSignal": true; }; "note": { "alias": "note"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "toggled": "toggled"; }, never, never, true, never>;
+}

package/lib/components/reissue-dialog/steps/reissue-notice/reissue-notice.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+/** Icon + message box used for the info callout, loading / error states and the validation hint. */
+export declare class SbdReissueNoticeComponent {
+    icon: import("@angular/core").InputSignal<string>;
+    tone: import("@angular/core").InputSignal<"error" | "success" | "info" | "warn" | "muted">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueNoticeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueNoticeComponent, "app-sbd-reissue-notice", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[action]"], true, never>;
+}

package/lib/components/reissue-dialog/steps/reissue-route-step/reissue-route-step.component.d.ts

@@ -0,0 +1,21 @@
+import { ReissueAirport } from '../../../../models/reissue.types';
+import { AirportOption, AirportSide, ReissueRouteRow } from '../../reissue.store';
+import * as i0 from "@angular/core";
+export declare class SbdReissueRouteStepComponent {
+    rows: import("@angular/core").InputSignal<ReissueRouteRow[]>;
+    options: import("@angular/core").InputSignal<AirportOption[]>;
+    airportChanged: import("@angular/core").OutputEmitterRef<{
+        legId: string;
+        side: AirportSide;
+        airport: ReissueAirport | null;
+    }>;
+    searched: import("@angular/core").OutputEmitterRef<string>;
+    swapped: import("@angular/core").OutputEmitterRef<string>;
+    readonly compare: (a: ReissueAirport, b: ReissueAirport) => boolean;
+    readonly sides: {
+        key: AirportSide;
+        label: string;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueRouteStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueRouteStepComponent, "app-sbd-reissue-route-step", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; }, { "airportChanged": "airportChanged"; "searched": "searched"; "swapped": "swapped"; }, never, never, true, never>;
+}

package/lib/components/reissue-dialog/steps/reissue-service-step/reissue-service-step.component.d.ts

@@ -0,0 +1,17 @@
+import { ReissueServiceKey } from '../../../../models/reissue.types';
+import * as i0 from "@angular/core";
+interface ServiceOption {
+    key: ReissueServiceKey;
+    icon: string;
+    title: string;
+    description: string;
+}
+export declare class SbdReissueServiceStepComponent {
+    upgradeAvailable: import("@angular/core").InputSignal<boolean>;
+    chosen: import("@angular/core").OutputEmitterRef<ReissueServiceKey>;
+    /** Upgrade Class is listed only when the upgrade-class API returned options. */
+    protected options: import("@angular/core").Signal<ServiceOption[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueServiceStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueServiceStepComponent, "app-sbd-reissue-service-step", never, { "upgradeAvailable": { "alias": "upgradeAvailable"; "required": false; "isSignal": true; }; }, { "chosen": "chosen"; }, never, never, true, never>;
+}
+export {};

package/lib/components/reissue-dialog/steps/reissue-upgrade-confirm-step/reissue-upgrade-confirm-step.component.d.ts

@@ -0,0 +1,28 @@
+import { ReissuePaymentLink } from '../../../../models/reissue.types';
+import { UpgradeSummaryRow } from '../../reissue-upgrade.store';
+import * as i0 from "@angular/core";
+export declare class SbdReissueUpgradeConfirmStepComponent {
+    rows: import("@angular/core").InputSignal<UpgradeSummaryRow[]>;
+    total: import("@angular/core").InputSignal<number>;
+    totalLabel: import("@angular/core").InputSignal<string>;
+    priceChanged: import("@angular/core").InputSignal<boolean>;
+    /** `book-now` was sent. */
+    booked: import("@angular/core").InputSignal<boolean>;
+    link: import("@angular/core").InputSignal<ReissuePaymentLink>;
+    error: import("@angular/core").InputSignal<string>;
+    /** The link expired and the agent chose to redo the upgrade from the beginning. */
+    restart: import("@angular/core").OutputEmitterRef<void>;
+    protected copied: import("@angular/core").WritableSignal<boolean>;
+    /** Ticks every second so the countdown (and the expired state) update on their own. */
+    private now;
+    private remainingMs;
+    protected expired: import("@angular/core").Signal<boolean>;
+    /** `mm:ss` until the link expires; empty when the backend sent no (valid) expiry. */
+    protected countdown: import("@angular/core").Signal<string>;
+    /** Last two minutes: highlight the countdown. */
+    protected soon: import("@angular/core").Signal<boolean>;
+    constructor();
+    protected copy(url: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueUpgradeConfirmStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueUpgradeConfirmStepComponent, "app-sbd-reissue-upgrade-confirm-step", never, { "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "totalLabel": { "alias": "totalLabel"; "required": false; "isSignal": true; }; "priceChanged": { "alias": "priceChanged"; "required": false; "isSignal": true; }; "booked": { "alias": "booked"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "restart": "restart"; }, never, never, true, never>;
+}

package/lib/components/reissue-dialog/steps/reissue-upgrade-step/reissue-upgrade-step.component.d.ts

@@ -0,0 +1,13 @@
+import { UpgradeSectionRow } from '../../reissue-upgrade.store';
+import * as i0 from "@angular/core";
+/** New-class options as radio cards, in the look of the cancel dialog's refund-method options. */
+export declare class SbdReissueUpgradeStepComponent {
+    sections: import("@angular/core").InputSignal<UpgradeSectionRow[]>;
+    error: import("@angular/core").InputSignal<string>;
+    picked: import("@angular/core").OutputEmitterRef<{
+        sectionId: string;
+        key: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdReissueUpgradeStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdReissueUpgradeStepComponent, "app-sbd-reissue-upgrade-step", never, { "sections": { "alias": "sections"; "required": true; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, { "picked": "picked"; }, never, never, true, never>;
+}

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

@@ -4,7 +4,7 @@ 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">;
+    status: import("@angular/core").InputSignal<"error" | "success" | "idle" | "loading">;
     result: import("@angular/core").InputSignal<ResultContent>;
     feedbackGiven: import("@angular/core").OutputEmitterRef<"up" | "down">;
     get elapsedSeconds(): string;

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

@@ -1,7 +1,9 @@
 import * as i0 from "@angular/core";
 export declare class SbdWorkflowActionsComponent {
     bookingId: import("@angular/core").InputSignal<string>;
+    showReissue: import("@angular/core").InputSignal<boolean>;
     cancelBooking: import("@angular/core").OutputEmitterRef<void>;
+    reissue: 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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdWorkflowActionsComponent, "app-sbd-workflow-actions", never, { "bookingId": { "alias": "bookingId"; "required": true; "isSignal": true; }; "showReissue": { "alias": "showReissue"; "required": false; "isSignal": true; }; }, { "cancelBooking": "cancelBooking"; "reissue": "reissue"; }, never, never, true, never>;
 }

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

@@ -1,4 +1,7 @@
 import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import type { Observable } from 'rxjs';
+/** Query/hash parameters (name -> value) the host adds to the link that opens the consumer web, e.g. its auth token. */
+export type SbdRedirectAuthParams = Record<string, string>;
 /**
  * Host-app configuration for the Smart Booking Dashboard.
  * Every field is optional; the defaults match the Almatar backoffice.
@@ -8,6 +11,32 @@ export interface SbdConfig {
     apiBase: string;
     /** Value of the `platform` header sent with FCR requests. Default: 'BO' */
     platform: string;
+    /**
+     * Base URL of the consumer web app the Reissue search redirects to, INCLUDING the language/country
+     * prefix the web requires, e.g. 'https://prelive-alpha.alm6ar.com/en/sa'. Without the prefix the web answers 404.
+     */
+    webBaseUrl: string;
+    /**
+     * Base of the customer payment page, WITHOUT the payment id, e.g. 'https://alpha3.alm6ar.com/en/payment'. The cart
+     * returns the link as a path only (`/<paymentId>`); this base is put in front of it to get the URL the agent sends.
+     * Not set (default) = a relative link is rejected instead of guessing a host.
+     */
+    paymentLinkBase?: string;
+    /**
+     * Auth parameters added to the web link that Change Date / Change Route open, so the web can call its APIs for the
+     * agent. The host decides the names and the values, for example Backoffice `{ 'bo-token': token }` and Helix
+     * `{ 'x-helix-token': token }`. It runs in an injection context (the host can `inject()` its auth service first) and
+     * may return the object, a Promise or an Observable. Not set = nothing is added. If it fails, the web still opens
+     * without the token.
+     */
+    redirectAuthParams?: () => SbdRedirectAuthParams | Promise<SbdRedirectAuthParams> | Observable<SbdRedirectAuthParams>;
+    /** Where `redirectAuthParams` go in the URL: the query string (default) or the `#fragment` (not sent to servers). */
+    redirectAuthIn?: 'query' | 'hash';
+    /**
+     * Show the Reissue button. Off by default so upgrading the package does not expose Reissue to agents before the host's
+     * backend serves the Reissue APIs; the host turns it on when they are ready.
+     */
+    reissueEnabled: boolean;
 }
 export declare const SBD_DEFAULT_CONFIG: SbdConfig;
 export declare const SBD_CONFIG: InjectionToken<SbdConfig>;