import { App } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_2<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_2<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare type AvailabilityStatus = 'available' | 'blocked' | 'checkout-only';

export declare interface Booking {
    id: string;
    guestName: string;
    roomNumber: string;
    checkIn: string;
    checkOut: string;
    status: string;
}

export declare type BookingStatus = 'confirmed' | 'pending' | 'cancelled' | 'checked-in' | 'checked-out' | 'no-show';

export declare interface CalendarDay {
    date: Date;
    dateString: string;
    isToday: boolean;
    isCurrentMonth: boolean;
    isPreviousMonth: boolean;
    isNextMonth: boolean;
    availability?: DateAvailability;
}

export declare interface CalendarEmits {
    'update:modelValue': [value: DateRange];
    'date-click': [date: string, status: AvailabilityStatus];
    'date-select': [date: Date];
    'selection-change': [selection: DateRange];
    'selection-error': [error: SelectionError | null];
    'price-calculation': [calculation: PriceCalculation | null];
    'book-now': [bookingData: {
        selection: DateRange;
        calculation: PriceCalculation;
    }];
}

export declare interface CalendarProps {
    modelValue: DateRange;
    availabilityData?: DateAvailability[];
    minDate?: string | Date;
    maxDate?: string | Date;
    locale?: string;
    disablePastDates?: boolean;
    allowPreviousMonthNavigation?: boolean;
    showPrices?: boolean;
    allowSingleDay?: boolean;
    theme?: 'light' | 'dark';
    basePrice?: number;
    currency?: string;
    showPriceCalculation?: boolean;
    showSelectionErrors?: boolean;
    textLabels?: CalendarTextLabels;
}

export declare interface CalendarTextLabels {
    previousMonth?: string;
    nextMonth?: string;
    bookingSummary?: string;
    nights?: string;
    night?: string;
    priceBreakdown?: string;
    total?: string;
    bookNow?: string;
    available?: string;
    checkoutOnly?: string;
    blocked?: string;
    clearSelection?: string;
    dismissError?: string;
}

export declare interface DashboardCalendarEmits {
    'update:selectedMonth': [value: Date];
    'booking-click': [booking: Booking];
    'booking-create': [data: {
        roomId: string;
        date: string;
    }];
}

export declare interface DashboardCalendarProps {
    rooms: Room[];
    bookings: Booking[];
    selectedMonth?: Date;
    theme?: 'light' | 'dark';
    statusConfig?: StatusConfig[];
    allowPreviousMonthNavigation?: boolean;
    textLabels?: DashboardTextLabels;
}

export declare interface DashboardTextLabels {
    previousMonth?: string;
    nextMonth?: string;
    room?: string;
    available?: string;
    createBooking?: string;
    clickForDetails?: string;
}

export declare interface DateAvailability {
    date: string;
    status: AvailabilityStatus;
    price?: number;
    minStay?: number;
    maxStay?: number;
}

export declare interface DateRange {
    checkIn: string | null;
    checkOut: string | null;
}

export declare const HotelBookingCalendar: __VLS_WithTemplateSlots<DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CalendarProps>, {
modelValue: () => {
checkIn: null;
checkOut: null;
};
availabilityData: () => never[];
locale: string;
disablePastDates: boolean;
allowPreviousMonthNavigation: boolean;
showPrices: boolean;
allowSingleDay: boolean;
theme: string;
basePrice: number;
currency: string;
showPriceCalculation: boolean;
showSelectionErrors: boolean;
textLabels: () => {};
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: DateRange) => void;
"date-click": (date: string, status: AvailabilityStatus) => void;
"date-select": (date: Date) => void;
"selection-change": (selection: DateRange) => void;
"selection-error": (error: SelectionError | null) => void;
"price-calculation": (calculation: PriceCalculation | null) => void;
"book-now": (bookingData: {
selection: DateRange;
calculation: PriceCalculation;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CalendarProps>, {
modelValue: () => {
checkIn: null;
checkOut: null;
};
availabilityData: () => never[];
locale: string;
disablePastDates: boolean;
allowPreviousMonthNavigation: boolean;
showPrices: boolean;
allowSingleDay: boolean;
theme: string;
basePrice: number;
currency: string;
showPriceCalculation: boolean;
showSelectionErrors: boolean;
textLabels: () => {};
}>>> & Readonly<{
"onUpdate:modelValue"?: ((value: DateRange) => any) | undefined;
"onDate-click"?: ((date: string, status: AvailabilityStatus) => any) | undefined;
"onDate-select"?: ((date: Date) => any) | undefined;
"onSelection-change"?: ((selection: DateRange) => any) | undefined;
"onSelection-error"?: ((error: SelectionError | null) => any) | undefined;
"onPrice-calculation"?: ((calculation: PriceCalculation | null) => any) | undefined;
"onBook-now"?: ((bookingData: {
selection: DateRange;
calculation: PriceCalculation;
}) => any) | undefined;
}>, {
modelValue: DateRange;
availabilityData: DateAvailability[];
locale: string;
disablePastDates: boolean;
allowPreviousMonthNavigation: boolean;
showPrices: boolean;
allowSingleDay: boolean;
theme: "light" | "dark";
basePrice: number;
currency: string;
showPriceCalculation: boolean;
showSelectionErrors: boolean;
textLabels: CalendarTextLabels;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    legend?(_: {}): any;
}>;

export declare const HotelDashboardCalendar: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<DashboardCalendarProps>, {
selectedMonth: () => Date;
theme: string;
allowPreviousMonthNavigation: boolean;
textLabels: () => {};
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:selectedMonth": (value: Date) => void;
"booking-click": (booking: Booking) => void;
"booking-create": (data: {
roomId: string;
date: string;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<DashboardCalendarProps>, {
selectedMonth: () => Date;
theme: string;
allowPreviousMonthNavigation: boolean;
textLabels: () => {};
}>>> & Readonly<{
"onUpdate:selectedMonth"?: ((value: Date) => any) | undefined;
"onBooking-click"?: ((booking: Booking) => any) | undefined;
"onBooking-create"?: ((data: {
roomId: string;
date: string;
}) => any) | undefined;
}>, {
allowPreviousMonthNavigation: boolean;
theme: "light" | "dark";
textLabels: DashboardTextLabels;
selectedMonth: Date;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const plugin: {
    install(app: App): void;
};
export default plugin;

export declare interface PriceCalculation {
    basePrice: number;
    nights: number;
    dailyPrices: {
        date: string;
        price: number;
    }[];
    totalPrice: number;
    currency: string;
    averagePerNight: number;
    taxesAndFees?: number;
    discounts?: number;
}

export declare interface Room {
    id: string;
    number: string;
}

export declare interface SelectionError {
    type: 'blocked-dates-in-range' | 'min-stay-not-met' | 'max-stay-exceeded' | 'invalid-range';
    message: string;
    blockedDates?: string[];
}

export declare interface StatusConfig {
    key: string;
    label: string;
    color: string;
    backgroundColor: string;
    darkBackgroundColor?: string;
}

export { }