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

package/lib/components/hotel-cancel/enums/almatar-hotel-auto-cancellation-endpoints.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum AlmatarHotelAutoCancellationEndpointsEnum {
+    getRefundDetails = "/api/v1/fcr/refund/backoffice/details",
+    processAutoCancellation = "/api/v1/fcr/refund/backoffice",
+    uploadAttachment = "/api/v1/fcr/refund/backoffice/upload-attachment",
+    nusukGetRefundDetails = "api/v1/nusuk/fcr/refund/details",
+    nusukProcessAutoCancellation = "api/v1/nusuk/fcr/refund"
+}

package/lib/components/hotel-cancel/enums/almatar-hotel-auto-cancellation-step.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum AlmatarHotelAutoCancellationStepEnum {
+    selectRooms = "select_rooms",
+    refundSummary = "refund_summary",
+    refundMethod = "refund_method"
+}

package/lib/components/hotel-cancel/interfaces/i-almatar-hotel-auto-cancellation.interface.d.ts

@@ -0,0 +1,252 @@
+export interface IAlmatarHotelAutoCancellationRoom {
+    packageId: string;
+    roomName: string;
+    roomType?: string;
+    mealPlan?: string;
+    isRefundable?: boolean;
+    isSelected?: boolean;
+    nights?: number;
+    roomAmount: number;
+    cancellationFee: number;
+    refundAmount: number;
+    cancellationDate?: string;
+    currentCancellation?: boolean;
+    route?: string;
+    bedType?: string;
+    roomView?: string;
+    roomBasis?: string;
+    refundability?: boolean;
+    refundableUntil?: string;
+    cancelledBefore?: boolean;
+    roomId?: string | undefined;
+    manualRefundRequest?: boolean;
+    fee?: number;
+    adultsNum?: number;
+    childrenNum?: number;
+    infantsNum?: number;
+    passengerName?: string;
+    isCancelled?: boolean;
+    supplier?: string;
+}
+export interface IAlmatarHotelAutoCancellationPackageRoom {
+    roomId: string;
+    roomName: string;
+    roomType?: string;
+    bedType?: string;
+    roomBasis?: string;
+}
+export interface IAlmatarHotelAutoCancellationPackage {
+    packageId: string;
+    packageName: string;
+    boardBasis?: string;
+    isRefundable?: boolean;
+    isSelected?: boolean;
+    refundability?: boolean;
+    refundableUntil?: string;
+    rooms: IAlmatarHotelAutoCancellationPackageRoom[];
+    roomAmount: number;
+    cancellationFee: number;
+    refundAmount: number;
+    manualRefundRequest?: boolean;
+    cancelledBefore?: boolean;
+    cancellationPolicies?: IBookingPackageCancellationPolicy[];
+    fee?: number;
+    cancellationPoliciesRemarks?: {
+        mandatory?: string;
+        optional?: string;
+    };
+    isCancelled?: boolean;
+    supplier?: string;
+}
+export interface IBookingPackageRoom {
+    roomId: string;
+    roomName: string;
+    roomType: string;
+    roomView: string;
+    roomBasis: string;
+    bedType: string;
+    adultsNum?: number;
+    childrenNum?: number;
+    infantsNum?: number;
+    passengers?: {
+        name?: string;
+    };
+}
+export interface IBookingPackageCancellationPolicy {
+    fromDate: string;
+    toDate: string;
+    penaltyType: string;
+    penaltyValue: number;
+}
+export interface IBookingPackage {
+    id: string;
+    rooms: IBookingPackageRoom[];
+    cancellationPolicies: IBookingPackageCancellationPolicy[];
+    isRefundable: boolean;
+    refundableUntil: string;
+    refundability: boolean;
+    cancellationPoliciesRemarks?: {
+        mandatory?: string;
+        optional?: string;
+    };
+    isCancelled?: boolean;
+    supplier?: string;
+}
+export interface IAlmatarHotelAutoCancellationHotelInfo {
+    hotelName: string;
+    hotelImage?: string;
+    checkIn: any;
+    checkOut: any;
+    totalRooms: number;
+    nights: number;
+    checkInTime: string;
+    checkOutTime: string;
+}
+export interface IAlmatarHotelAutoCancellationRefundSummary {
+    totalPaid: number;
+    totalRefund: number;
+    rooms: IAlmatarHotelAutoCancellationRoom[];
+    packages?: IAlmatarHotelAutoCancellationRefundPackage[];
+    summaries?: IRefundSummaryItem[];
+    payout?: IRefundPayout;
+    totals?: any;
+    totalFees?: number;
+    coupon?: number;
+    giftsTotal?: number;
+    giftsDetails?: IGift[];
+    serviceFee?: number;
+    surcharge?: number;
+    goldenGift?: boolean;
+    previousRooms?: IRefundPreviousRoom[];
+}
+export interface IRefundRoomPax {
+    adults: number;
+    children: number;
+    total: number;
+}
+export interface IAlmatarHotelAutoCancellationRefundPackageRoom {
+    roomId: string;
+    roomName: string;
+    basis?: string;
+    nights?: number;
+    pax?: IRefundRoomPax;
+    adults?: number;
+    children?: number;
+}
+export interface IGroupedRoom {
+    roomName: string;
+    count: number;
+    nights?: number;
+    adults?: number;
+    basis?: string;
+}
+export interface IAlmatarHotelAutoCancellationRefundPackage {
+    packageId: string;
+    packageName: string;
+    rooms: IAlmatarHotelAutoCancellationRefundPackageRoom[];
+    amount: number;
+    fee: number;
+    serviceFee: number;
+    refund: number;
+    refundable: boolean;
+    route?: string;
+    cancellationDate?: string;
+    cancelledBefore?: boolean;
+}
+export interface IRefundDetailsApiResponse {
+    status: number;
+    data: IRefundDetailsData;
+    errors: any;
+}
+export interface IRefundDetailsData {
+    bookingId: number;
+    currency: string;
+    status: string;
+    message: string;
+    flags: IRefundFlags;
+    selection: IRefundSelection;
+    totals: IRefundTotals;
+    previous: IRefundPreviousRoom[];
+    current: IRefundCurrent;
+    payout: IRefundPayout;
+    summaries: IRefundSummaryItem[];
+    gifts: IGift[];
+}
+export interface IRefundFlags {
+    refundable: boolean;
+    partial: boolean;
+    goldenGift: boolean;
+}
+export interface IRefundSelection {
+    packageIds: string[];
+}
+export interface IRefundTotals {
+    paid: number;
+    beforeCoupon: number;
+    roomsBooked: number;
+    coupon: number;
+    gifts: number;
+    serviceFee: number;
+    wallet: number;
+    card: number;
+    tabby: number;
+    tamara: number;
+    mokafa: number;
+    qitaf: number;
+}
+export interface IRefundPreviousRoom {
+    packageId: string;
+    roomName: string;
+    amount: number;
+    fee: number;
+    refunded: number;
+    cancelledAt: string;
+    roomId?: string | undefined;
+    nights?: any;
+}
+export interface IRefundCurrentRoom {
+    packageId: string;
+    roomName: string;
+    amount: number;
+    fee: number;
+    refund: number;
+    refundable: boolean;
+    route: string;
+    roomId?: string | undefined;
+    nights?: any;
+}
+export interface IRefundCurrent {
+    rooms: IRefundCurrentRoom[];
+    amount: number;
+    fee: number;
+    surcharge: number;
+    refund: number;
+}
+export interface IRefundPayout {
+    alreadyRefunded: number;
+    current: number;
+    afterThis: number;
+    feesTotal: number;
+    wallet: number;
+    card: number;
+    tabby: number;
+    tamara: number;
+    loyaltyToWallet: number;
+    note: string | null;
+}
+export interface IRefundSummaryItem {
+    code: string;
+    label: string;
+    paid: number;
+    refund: number;
+    refundable: boolean;
+    gateway?: string;
+}
+export interface IGift {
+    id: number;
+    key: string | null;
+    name: string;
+    amount: number;
+    refundable: boolean;
+    refund: number;
+}

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

@@ -0,0 +1,88 @@
+import { Observable } from 'rxjs';
+import { IAlmatarHotelAutoCancellationRoom, IAlmatarHotelAutoCancellationRefundSummary, IAlmatarHotelAutoCancellationRefundPackage, IRefundDetailsApiResponse, IRefundDetailsData } from '../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+export interface IRefundDetailsRequest {
+    bookingId: string;
+    product: 'hotels';
+    packageIds: string[];
+}
+export interface IProcessCancellationRequest {
+    bookingId: string;
+    product: 'hotels';
+    packageIds: string[];
+    preferredPaymentMethod?: string;
+}
+export interface IProcessNonRefundableCancellationRequest {
+    bookingId: string;
+    product: 'hotels';
+    packageIds: string[];
+    preferredPaymentMethod: string;
+    processedMode: 'auto';
+    language: string;
+    attachmentUrl: string;
+}
+export interface IAutoCancellationProcessResponse {
+    status: number;
+    data: {
+        error: string;
+        message: string;
+        bookingId: number;
+        preferredPaymentMethod: string;
+        isWhatsApp?: boolean;
+        cancel: {
+            status: string;
+            packageIds: string[];
+        };
+        refund: {
+            status: string;
+            bookingStatus: string;
+            amount: number;
+            currency: string;
+            breakdown: {
+                wallet: number;
+                mokafa: number;
+                qitaf: number;
+                card: number;
+                tabby: number;
+                tamara: number;
+            };
+        };
+    };
+    errors: any;
+}
+export declare class AlmatarHotelAutoCancellationEndpointsService {
+    private readonly api;
+    private readonly apiBase;
+    private readonly route;
+    private readonly hotelManageBookingService;
+    private readonly _almatarBookingId;
+    private readonly _confirmationNumber;
+    private readonly _isNusukFlow;
+    private readonly _selectedPackageIds;
+    readonly almatarBookingId: import("@angular/core").Signal<string>;
+    readonly confirmationNumber: import("@angular/core").Signal<string>;
+    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;
+    getAllPackages(data: IRefundDetailsData): IAlmatarHotelAutoCancellationRefundPackage[];
+    getAllRooms(data: IRefundDetailsData): IAlmatarHotelAutoCancellationRoom[];
+    processAutoCancellation(packageIds: string[], refundOption?: string): Observable<IAutoCancellationProcessResponse>;
+    processNonRefundableCancellation(packageId: string, attachmentUrl: string, language?: string): Observable<IAutoCancellationProcessResponse>;
+    calculateLocalRefundSummary(rooms: IAlmatarHotelAutoCancellationRoom[]): IAlmatarHotelAutoCancellationRefundSummary;
+    getSelectedPackageIds(): string[];
+    clearSelectedPackageIds(): void;
+    private getEntrySourceDeviceBrand;
+    private getEntrySource;
+    private getDevice;
+    private handleError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationEndpointsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlmatarHotelAutoCancellationEndpointsService>;
+}

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

@@ -0,0 +1,21 @@
+import { AlmatarHotelAutoCancellationStepEnum } from '../enums/almatar-hotel-auto-cancellation-step.enum';
+import { IAlmatarHotelAutoCancellationRoom, IAlmatarHotelAutoCancellationHotelInfo, IAlmatarHotelAutoCancellationRefundSummary } from '../interfaces/i-almatar-hotel-auto-cancellation.interface';
+import * as i0 from "@angular/core";
+export declare class AlmatarHotelAutoCancellationService {
+    readonly currentStep: import("@angular/core").WritableSignal<AlmatarHotelAutoCancellationStepEnum>;
+    readonly selectedRooms: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationRoom[]>;
+    readonly hotelInfo: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationHotelInfo>;
+    readonly refundSummary: import("@angular/core").WritableSignal<IAlmatarHotelAutoCancellationRefundSummary>;
+    readonly selectedRoomsCount: import("@angular/core").Signal<number>;
+    readonly hasSelectedRooms: import("@angular/core").Signal<boolean>;
+    readonly totalRefundAmount: import("@angular/core").Signal<number>;
+    setCurrentStep(step: AlmatarHotelAutoCancellationStepEnum): void;
+    setSelectedRooms(rooms: IAlmatarHotelAutoCancellationRoom[]): void;
+    setHotelInfo(info: IAlmatarHotelAutoCancellationHotelInfo): void;
+    setRefundSummary(summary: IAlmatarHotelAutoCancellationRefundSummary): void;
+    toggleRoomSelection(packageId: string): void;
+    calculateRefundSummary(rooms: IAlmatarHotelAutoCancellationRoom[], totalPaid: number): IAlmatarHotelAutoCancellationRefundSummary;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarHotelAutoCancellationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlmatarHotelAutoCancellationService>;
+}

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

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+export declare class SbdHotelItineraryCardComponent {
+    data: import("@angular/core").InputSignal<any>;
+    verified: import("@angular/core").InputSignal<boolean>;
+    private bi;
+    hotelInfo: import("@angular/core").Signal<any>;
+    checkinCheckout: import("@angular/core").Signal<any>;
+    roomInfo: 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SbdHotelItineraryCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SbdHotelItineraryCardComponent, "app-sbd-hotel-itinerary-card", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "verified": { "alias": "verified"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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>;
+}