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

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,82 @@
+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 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;
+    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/shared/components/confirm-modal/confirm-modal.component.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ConfirmModalComponent {
+    visible: boolean;
+    title: string;
+    message: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    visibleChange: EventEmitter<boolean>;
+    confirm: EventEmitter<void>;
+    cancel: EventEmitter<void>;
+    onConfirm(): void;
+    onCancel(): void;
+    private close;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmModalComponent, "confirm-modal", never, { "visible": { "alias": "visible"; "required": false; }; "title": { "alias": "title"; "required": false; }; "message": { "alias": "message"; "required": false; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; }, { "visibleChange": "visibleChange"; "confirm": "confirm"; "cancel": "cancel"; }, never, never, true, never>;
+}

package/lib/components/shared/components/manage-booking-failed-modal/manage-booking-failed-modal.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ManageBookingFailedModalComponent {
+    visible: boolean;
+    message: string;
+    visibleChange: EventEmitter<boolean>;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManageBookingFailedModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManageBookingFailedModalComponent, "manage-booking-failed-modal", never, { "visible": { "alias": "visible"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}

package/lib/components/shared/enums/hotel-manage-booking-aside-tab.enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum HotelManageBookingAsideTabEnum {
+    DETAILS = "details",
+    CANCELLATION = "cancellation",
+    MODIFICATION = "modification",
+    REFUND = "refund",
+    whatsAppAgent = "whatsAppAgent"
+}

package/lib/components/shared/interfaces/i-flight-refund-details.d.ts

@@ -0,0 +1,73 @@
+export interface IRefundDetailsData {
+    bookingId?: string | number;
+    refundAmount?: number;
+    totalRefundAmount?: number;
+    walletRefundAmount?: number;
+    totalCardRefundAmount?: number;
+    totalLoyaltyPointsRefundAmount?: number;
+    totalLoyaltyPoints?: number;
+    currency?: string;
+    refundMethod?: RefundPreferredMethod | string;
+    paymentGateway?: PaymentGatewayCode | LoyaltyPaymentType | string;
+    loyaltyPaymentType?: LoyaltyPaymentType | string;
+    isFullWalletRefundAllowed?: boolean;
+    paymentMethodCustomerUsed?: string;
+    isRefundable?: boolean;
+}
+export type RefundPreferredMethod = 'ORIGINAL_PAYMENT_METHOD' | 'WALLET' | 'wallet' | 'originalPaymentMethod' | 'BANK_TRANSFER' | 'LOYALTY_POINTS';
+export type LoyaltyPaymentType = 'ALMATAR_POINTS' | 'ALFURSAN' | 'AlRajhiMokafaa' | 'Qitaf' | 'Wala';
+export declare enum PaymentGatewayCode {
+    MADA = "MADA",
+    VISA = "VISA",
+    MASTERCARD = "MASTERCARD",
+    AMEX = "AMEX",
+    APPLE_PAY = "APPLE_PAY",
+    AlRajhiMokafaa = "RAJHI",
+    Qitaf = "QITAF",
+    Wala = "WALA",
+    Tamara = "TM",
+    Tabby = "TB",
+    Stc = "STC",
+    CH = "CH",
+    HP = "HP",
+    MF = "MF",
+    WT = "WT",
+    TM = "TM",
+    TB = "TB",
+    RAJHI = "RAJHI",
+    STC = "STC",
+    PPB = "PPB",
+    PP = "PP",
+    TAMAM = "TAMAM",
+    QITAF = "QITAF",
+    WALA = "WALA"
+}
+/** Labels for `paymentMethodCustomerUsed` gateway codes returned by the backend. */
+export declare const PAYMENT_GATEWAY_LABELS: Record<string, {
+    en: string;
+    ar: string;
+}>;
+/** Gateway codes that refund to an installment plan rather than the original card. */
+export declare const INSTALLMENT_GATEWAY_CODES: string[];
+/** Gateway codes that refund to a loyalty-program account rather than the original card. */
+export declare const LOYALTY_GATEWAY_CODES: string[];
+/**
+ * Internal payment-processor/gateway names, never customer-recognizable
+ * brands — must not be surfaced verbatim (e.g. a card refund processed
+ * through Hyperpay must read as "Card"/"Original Payment Method", never
+ * "Hyperpay"). Callers fall back to a generic label whenever the normalized
+ * lookup returns ''.
+ */
+export declare const INTERNAL_GATEWAY_CODES: string[];
+/**
+ * Result/confirmation-screen-only override: these gateways process card
+ * payments through Mada — shown specifically as "Mada Card" instead of
+ * falling back to the generic "Original Payment Method" label used
+ * everywhere else `INTERNAL_GATEWAY_CODES` applies.
+ */
+export declare const MADA_GATEWAY_CODES: string[];
+/**
+ * Normalizes a raw payment gateway code from the backend to a standardized code.
+ * Handles both uppercase codes (e.g. 'HP') and labels (e.g. 'Hyperpay').
+ */
+export declare function normalizePaymentGatewayCode(raw?: string | null): PaymentGatewayCode | '';

package/lib/components/shared/models/cancel-hotel-booking.model.d.ts

@@ -0,0 +1,6 @@
+export declare class CancelHotelBookingPayload {
+    bookingId?: string;
+    roomIds?: string[];
+    refundMethod?: string;
+    constructor(data?: Partial<CancelHotelBookingPayload>);
+}

package/lib/components/shared/services/hotel-manage-booking/hotel-manage-booking.service.d.ts

@@ -0,0 +1,11 @@
+import { Observable, BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HotelManageBookingService {
+    private activeAsideTab;
+    selectedHotelBooking: BehaviorSubject<any>;
+    getActiveAsideTab(): string;
+    setActiveAsideTab(tab: string): void;
+    getBookingDetails(bookingId: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotelManageBookingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HotelManageBookingService>;
+}

package/lib/components/shared/services/hotel-manage-booking-endpoints/hotel-manage-booking-endpoints.service.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HotelManageBookingEndpointsService {
+    cancelBookingRequest(payload: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotelManageBookingEndpointsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HotelManageBookingEndpointsService>;
+}

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

@@ -1,6 +1,34 @@
+import { IBookingPackage } from '../components/hotel-cancel/interfaces/i-almatar-hotel-auto-cancellation.interface';
 export type ProductType = 'flight' | 'hotel';
 export type BookingStatus = 'idle' | 'loading' | 'success' | 'error';
 export interface BookingResponse {
     data: any;
     elapsedMs: number;
 }
+export interface IHotelBookingData {
+    hotelId?: string | number;
+    bookingId?: string | number;
+    hotelName?: string;
+    coverImage?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    from?: {
+        _i?: string;
+    };
+    to?: {
+        _i?: string;
+    };
+    packages?: IBookingPackage[];
+    rooms?: number;
+    numberOfNights?: number;
+    nightNumber?: number;
+    checkInTime?: string;
+    checkOutTime?: string;
+    price?: number;
+    data?: any;
+}
+/**
+ * Maps raw API response to IHotelBookingData interface
+ * This function handles the actual API response format from the booking endpoint
+ */
+export declare function mapToHotelBookingData(apiResponse: any): IHotelBookingData | null;

package/lib/pages/smart-booking-dashboard/smart-booking-dashboard.component.d.ts

@@ -8,6 +8,7 @@ export declare class SmartBookingDashboardComponent {
     bookingStatus: import("@angular/core").WritableSignal<"error" | "idle" | "loading" | "success">;
     bookingData: import("@angular/core").WritableSignal<any>;
     cancelDialogOpen: import("@angular/core").WritableSignal<boolean>;
+    hotelAutoCancelDialogOpen: import("@angular/core").WritableSignal<boolean>;
     actionDialogOpen: import("@angular/core").WritableSignal<boolean>;
     addNoteDialogOpen: import("@angular/core").WritableSignal<boolean>;
     selectedActionKey: import("@angular/core").WritableSignal<string>;

package/lib/shared/components/currency-code-icon/currency-code-icon.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare enum CurrencySizeEnum {
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    LG = "large"
+}
+export declare class CurrencyCodeIconComponent {
+    currencyCode: string;
+    size: CurrencySizeEnum;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrencyCodeIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CurrencyCodeIconComponent, "currency-code-icon", never, { "currencyCode": { "alias": "currencyCode"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/shared/enums/brand-enums.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum brandEnum {
+    almatar = "almatar",
+    rehlat = "rehlat",
+    tajawal = "tajawal"
+}

package/lib/shared/environments/environment.d.ts

@@ -0,0 +1,7 @@
+export declare const environments: {
+    production: boolean;
+    apiUrl: string;
+    baseUrl: string;
+    isTenant: boolean;
+    brandName: string;
+};

package/lib/shared/models/index.d.ts

@@ -0,0 +1,11 @@
+export interface ICurrency {
+    code: string;
+    name?: string;
+    symbol?: string;
+    rate?: number;
+}
+export declare const loyaltyPointsMethods: {
+    readonly ALMATAR_POINTS: "ALMATAR_POINTS";
+    readonly ALFURSAN: "ALFURSAN";
+};
+export type LoyaltyPointsMethod = typeof loyaltyPointsMethods[keyof typeof loyaltyPointsMethods];

package/lib/shared/modules/almatar-icon/almatar-icon.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export declare class AlmatarIconComponent {
+    name: string;
+    size: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlmatarIconComponent, "almatar-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class AlmatarIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlmatarIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AlmatarIconModule, never, [typeof i1.CommonModule, typeof AlmatarIconComponent], [typeof AlmatarIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AlmatarIconModule>;
+}

package/lib/shared/modules/loader/loader.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export declare class LoaderComponent {
+    loading: boolean;
+    message: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "app-loader", never, { "loading": { "alias": "loading"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class LoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LoaderModule, never, [typeof i1.CommonModule, typeof LoaderComponent], [typeof LoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LoaderModule>;
+}

package/lib/shared/pipes/exchange.pipe.d.ts

@@ -0,0 +1,17 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ExchangePipe implements PipeTransform {
+    transform(value: number, currency?: string, rate?: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExchangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ExchangePipe, "exchange", true>;
+}
+export declare class ExchangeRoundPipe implements PipeTransform {
+    transform(value: number, currency?: string, rate?: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExchangeRoundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ExchangeRoundPipe, "exchange_round", true>;
+}
+export declare class ExchangePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExchangePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExchangePipeModule, never, [typeof ExchangePipe, typeof ExchangeRoundPipe], [typeof ExchangePipe, typeof ExchangeRoundPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExchangePipeModule>;
+}