@debugged-development/ticketapp-sdk 1.0.9 → 1.0.10-dev.0

package/dist/store/store.d.ts

@@ -1,12 +1,3133 @@
-export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
-    basket: import("./basketSlice").BasketState;
-    event: import("./eventSlice").EventState;
-}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
-    dispatch: import("redux-thunk").ThunkDispatch<{
-        basket: import("./basketSlice").BasketState;
-        event: import("./eventSlice").EventState;
-    }, undefined, import("redux").UnknownAction>;
-}>, import("redux").StoreEnhancer]>>;
-export type RootState = ReturnType<typeof store.getState>;
-export type AppDispatch = typeof store.dispatch;
+import { PayloadAction } from '@reduxjs/toolkit';
+import { DateTime } from 'luxon';
+import { Order, BasketOrderType, Currency, ProductInput, ConfigurePackageInput, ConfigureDeliveryInput, ConfigureCustomerInput, ReserveAdditionalPackageItemInput } from '@/types';
+export interface BasketState {
+    order: Order | null;
+    processing: boolean;
+    error: string | null;
+}
+export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState, {
+    setProcessing: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<boolean>) => void;
+    setError: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<string | null>) => void;
+    setOrder: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<Order | null>) => void;
+    initializeOrder: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<{
+        id: string;
+        currency: Currency;
+        expiredAt?: DateTime | null;
+    }>) => void;
+    addProduct: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<{
+        input: ProductInput;
+        amountReserved: number;
+        expiredAt?: DateTime | null;
+    }>) => void;
+    removeProduct: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<{
+        id: string;
+        amountReleased: number;
+        seatId?: string;
+    }>) => void;
+    configurePackage: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<{
+        input: ConfigurePackageInput;
+        amountReserved: number;
+        expiredAt?: DateTime | null;
+    }>) => void;
+    reserveAdditionalPackageItem: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<{
+        input: ReserveAdditionalPackageItemInput;
+        amountReserved: number;
+        expiredAt?: DateTime | null;
+    }>) => void;
+    configureDelivery: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<ConfigureDeliveryInput | undefined>) => void;
+    configureCustomer: (state: {
+        order: {
+            id: string;
+            currency: Currency;
+            customer?: any;
+            items: {
+                id: string;
+                type: BasketOrderType;
+                name: string;
+                icon?: string | null | undefined;
+                description?: string | null | undefined;
+                amount: number;
+                maxAmountOfAddons?: number | undefined;
+                minAmountOfAddons?: number | undefined;
+                price?: number | null | undefined;
+                originalPrice?: number | null | undefined;
+                depositPrice?: number | null | undefined;
+                serviceFee?: number | null | undefined;
+                seats?: {
+                    id: string;
+                    label: string;
+                }[] | undefined;
+                packageItems?: {
+                    packageItemId: string;
+                    eventId: string;
+                    name: string;
+                    startAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                    endAt: {
+                        get: (unit: keyof DateTime) => number;
+                        getPossibleOffsets: () => DateTime<boolean>[];
+                        isValid: boolean;
+                        invalidReason: string | null;
+                        invalidExplanation: string | null;
+                        locale: string | null;
+                        numberingSystem: string | null;
+                        outputCalendar: string | null;
+                        zone: {
+                            type: string;
+                            name: string;
+                            isUniversal: boolean;
+                            offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                            formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                            offset: (ts: number) => number;
+                            equals: (other: import("luxon").Zone) => boolean;
+                            isValid: boolean;
+                        };
+                        zoneName: string | null;
+                        year: number;
+                        quarter: number;
+                        month: number;
+                        day: number;
+                        hour: number;
+                        minute: number;
+                        second: number;
+                        millisecond: number;
+                        weekYear: number;
+                        weekNumber: number;
+                        weekday: number;
+                        isWeekend: boolean;
+                        localWeekday: number;
+                        localWeekNumber: number;
+                        localWeekYear: number;
+                        ordinal: number;
+                        monthShort: string | null;
+                        monthLong: string | null;
+                        weekdayShort: string | null;
+                        weekdayLong: string | null;
+                        offset: number;
+                        offsetNameShort: string | null;
+                        offsetNameLong: string | null;
+                        isOffsetFixed: boolean | null;
+                        isInDST: boolean;
+                        isInLeapYear: boolean;
+                        daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                        daysInYear: number;
+                        weeksInWeekYear: number;
+                        weeksInLocalWeekYear: number;
+                        resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                        toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                        toLocal: () => DateTime<boolean>;
+                        setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                        reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                        setLocale: (locale: string) => DateTime<boolean>;
+                        set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                        plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                        startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                        endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                        toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                        toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                        toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                        toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                        toISOWeekDate: () => string | null;
+                        toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                        toRFC2822: () => string | null;
+                        toHTTP: () => string | null;
+                        toSQLDate: () => string | null;
+                        toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                        toString: () => string;
+                        valueOf: () => number;
+                        toMillis: () => number;
+                        toSeconds: () => number;
+                        toUnixInteger: () => number;
+                        toJSON: () => string | null;
+                        toBSON: () => Date;
+                        toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                            includeConfig?: IncludeConfig | undefined;
+                        } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                        toJSDate: () => Date;
+                        diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                        diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                        until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                        hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                        equals: (other: DateTime) => boolean;
+                        toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                        toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+                    };
+                }[] | undefined;
+            }[];
+            expiredAt?: {
+                get: (unit: keyof DateTime) => number;
+                getPossibleOffsets: () => DateTime<boolean>[];
+                isValid: boolean;
+                invalidReason: string | null;
+                invalidExplanation: string | null;
+                locale: string | null;
+                numberingSystem: string | null;
+                outputCalendar: string | null;
+                zone: {
+                    type: string;
+                    name: string;
+                    isUniversal: boolean;
+                    offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
+                    formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
+                    offset: (ts: number) => number;
+                    equals: (other: import("luxon").Zone) => boolean;
+                    isValid: boolean;
+                };
+                zoneName: string | null;
+                year: number;
+                quarter: number;
+                month: number;
+                day: number;
+                hour: number;
+                minute: number;
+                second: number;
+                millisecond: number;
+                weekYear: number;
+                weekNumber: number;
+                weekday: number;
+                isWeekend: boolean;
+                localWeekday: number;
+                localWeekNumber: number;
+                localWeekYear: number;
+                ordinal: number;
+                monthShort: string | null;
+                monthLong: string | null;
+                weekdayShort: string | null;
+                weekdayLong: string | null;
+                offset: number;
+                offsetNameShort: string | null;
+                offsetNameLong: string | null;
+                isOffsetFixed: boolean | null;
+                isInDST: boolean;
+                isInLeapYear: boolean;
+                daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
+                daysInYear: number;
+                weeksInWeekYear: number;
+                weeksInLocalWeekYear: number;
+                resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
+                toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
+                toLocal: () => DateTime<boolean>;
+                setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
+                reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
+                setLocale: (locale: string) => DateTime<boolean>;
+                set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
+                plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
+                startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
+                endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
+                toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
+                toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
+                toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
+                toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
+                toISOWeekDate: () => string | null;
+                toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
+                toRFC2822: () => string | null;
+                toHTTP: () => string | null;
+                toSQLDate: () => string | null;
+                toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
+                toString: () => string;
+                valueOf: () => number;
+                toMillis: () => number;
+                toSeconds: () => number;
+                toUnixInteger: () => number;
+                toJSON: () => string | null;
+                toBSON: () => Date;
+                toObject: <IncludeConfig extends boolean | undefined>(opts?: {
+                    includeConfig?: IncludeConfig | undefined;
+                } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
+                toJSDate: () => Date;
+                diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
+                diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
+                until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
+                hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
+                equals: (other: DateTime) => boolean;
+                toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
+                toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
+            } | null | undefined;
+        } | null;
+        processing: boolean;
+        error: string | null;
+    }, action: PayloadAction<ConfigureCustomerInput>) => void;
+    clearBasket: () => BasketState;
+}, "basket", "basket", import("@reduxjs/toolkit").SliceSelectors<BasketState>>;
+export declare const setProcessing: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "basket/setProcessing">, initializeOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: string;
+    currency: Currency;
+    expiredAt?: DateTime | null;
+}, "basket/initializeOrder">, addProduct: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    input: ProductInput;
+    amountReserved: number;
+    expiredAt?: DateTime | null;
+}, "basket/addProduct">, removeProduct: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: string;
+    amountReleased: number;
+    seatId?: string;
+}, "basket/removeProduct">, configurePackage: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    input: ConfigurePackageInput;
+    amountReserved: number;
+    expiredAt?: DateTime | null;
+}, "basket/configurePackage">, configureDelivery: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ConfigureDeliveryInput | undefined, "basket/configureDelivery">, configureCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<ConfigureCustomerInput, "basket/configureCustomer">, reserveAdditionalPackageItem: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    input: ReserveAdditionalPackageItemInput;
+    amountReserved: number;
+    expiredAt?: DateTime | null;
+}, "basket/reserveAdditionalPackageItem">, clearBasket: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"basket/clearBasket">;
 //# sourceMappingURL=store.d.ts.map