@ticketapp-dev/shop-sdk 1.0.16 → 1.0.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/dist/index.js +278 -258
  2. package/dist/services/basket/basket.service.d.ts.map +1 -1
  3. package/dist/services/basket/basket.service.generated.d.ts +18 -4
  4. package/dist/services/basket/basket.service.generated.d.ts.map +1 -1
  5. package/dist/store/store.d.ts +38 -2769
  6. package/dist/store/store.d.ts.map +1 -1
  7. package/dist/types/index.d.ts +20 -10
  8. package/dist/types/index.d.ts.map +1 -1
  9. package/dist/utils/persisted-query/persisted-query-client.d.ts.map +1 -1
  10. package/package.json +1 -1
package/dist/store/store.d.ts CHANGED
@@ -1,5 +1,4 @@
1
1
  import { PayloadAction } from '@reduxjs/toolkit';
2
- import { DateTime } from 'luxon';
3
2
  import { Order, BasketOrderType, Currency, ProductInput, ConfigurePackageInput, ConfigureDeliveryInput, ConfigureCustomerInput, ReserveAdditionalPackageItemInput } from '@/types';
4
3
  export interface BasketState {
5
4
  order: Order | null;
@@ -33,284 +32,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
33
32
  packageItemId: string;
34
33
  eventId: string;
35
34
  name: string;
36
- startAt: {
37
- get: (unit: keyof DateTime) => number;
38
- getPossibleOffsets: () => DateTime<boolean>[];
39
- isValid: boolean;
40
- invalidReason: string | null;
41
- invalidExplanation: string | null;
42
- locale: string | null;
43
- numberingSystem: string | null;
44
- outputCalendar: string | null;
45
- zone: {
46
- type: string;
47
- name: string;
48
- isUniversal: boolean;
49
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
50
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
51
- offset: (ts: number) => number;
52
- equals: (other: import("luxon").Zone) => boolean;
53
- isValid: boolean;
54
- };
55
- zoneName: string | null;
56
- year: number;
57
- quarter: number;
58
- month: number;
59
- day: number;
60
- hour: number;
61
- minute: number;
62
- second: number;
63
- millisecond: number;
64
- weekYear: number;
65
- weekNumber: number;
66
- weekday: number;
67
- isWeekend: boolean;
68
- localWeekday: number;
69
- localWeekNumber: number;
70
- localWeekYear: number;
71
- ordinal: number;
72
- monthShort: string | null;
73
- monthLong: string | null;
74
- weekdayShort: string | null;
75
- weekdayLong: string | null;
76
- offset: number;
77
- offsetNameShort: string | null;
78
- offsetNameLong: string | null;
79
- isOffsetFixed: boolean | null;
80
- isInDST: boolean;
81
- isInLeapYear: boolean;
82
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
83
- daysInYear: number;
84
- weeksInWeekYear: number;
85
- weeksInLocalWeekYear: number;
86
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
87
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
88
- toLocal: () => DateTime<boolean>;
89
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
90
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
91
- setLocale: (locale: string) => DateTime<boolean>;
92
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
93
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
94
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
95
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
96
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
97
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
98
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
99
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
100
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
101
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
102
- toISOWeekDate: () => string | null;
103
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
104
- toRFC2822: () => string | null;
105
- toHTTP: () => string | null;
106
- toSQLDate: () => string | null;
107
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
108
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
109
- toString: () => string;
110
- valueOf: () => number;
111
- toMillis: () => number;
112
- toSeconds: () => number;
113
- toUnixInteger: () => number;
114
- toJSON: () => string | null;
115
- toBSON: () => Date;
116
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
117
- includeConfig?: IncludeConfig | undefined;
118
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
119
- toJSDate: () => Date;
120
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
121
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
122
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
123
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
124
- equals: (other: DateTime) => boolean;
125
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
126
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
127
- };
128
- endAt: {
129
- get: (unit: keyof DateTime) => number;
130
- getPossibleOffsets: () => DateTime<boolean>[];
131
- isValid: boolean;
132
- invalidReason: string | null;
133
- invalidExplanation: string | null;
134
- locale: string | null;
135
- numberingSystem: string | null;
136
- outputCalendar: string | null;
137
- zone: {
138
- type: string;
139
- name: string;
140
- isUniversal: boolean;
141
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
142
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
143
- offset: (ts: number) => number;
144
- equals: (other: import("luxon").Zone) => boolean;
145
- isValid: boolean;
146
- };
147
- zoneName: string | null;
148
- year: number;
149
- quarter: number;
150
- month: number;
151
- day: number;
152
- hour: number;
153
- minute: number;
154
- second: number;
155
- millisecond: number;
156
- weekYear: number;
157
- weekNumber: number;
158
- weekday: number;
159
- isWeekend: boolean;
160
- localWeekday: number;
161
- localWeekNumber: number;
162
- localWeekYear: number;
163
- ordinal: number;
164
- monthShort: string | null;
165
- monthLong: string | null;
166
- weekdayShort: string | null;
167
- weekdayLong: string | null;
168
- offset: number;
169
- offsetNameShort: string | null;
170
- offsetNameLong: string | null;
171
- isOffsetFixed: boolean | null;
172
- isInDST: boolean;
173
- isInLeapYear: boolean;
174
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
175
- daysInYear: number;
176
- weeksInWeekYear: number;
177
- weeksInLocalWeekYear: number;
178
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
179
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
180
- toLocal: () => DateTime<boolean>;
181
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
182
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
183
- setLocale: (locale: string) => DateTime<boolean>;
184
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
185
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
186
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
187
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
188
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
189
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
190
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
191
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
192
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
193
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
194
- toISOWeekDate: () => string | null;
195
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
196
- toRFC2822: () => string | null;
197
- toHTTP: () => string | null;
198
- toSQLDate: () => string | null;
199
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
200
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
201
- toString: () => string;
202
- valueOf: () => number;
203
- toMillis: () => number;
204
- toSeconds: () => number;
205
- toUnixInteger: () => number;
206
- toJSON: () => string | null;
207
- toBSON: () => Date;
208
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
209
- includeConfig?: IncludeConfig | undefined;
210
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
211
- toJSDate: () => Date;
212
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
213
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
214
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
215
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
216
- equals: (other: DateTime) => boolean;
217
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
218
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
219
- };
35
+ startAt: string;
36
+ endAt: string;
220
37
  }[] | undefined;
221
38
  }[];
222
- expiredAt?: {
223
- get: (unit: keyof DateTime) => number;
224
- getPossibleOffsets: () => DateTime<boolean>[];
225
- isValid: boolean;
226
- invalidReason: string | null;
227
- invalidExplanation: string | null;
228
- locale: string | null;
229
- numberingSystem: string | null;
230
- outputCalendar: string | null;
231
- zone: {
232
- type: string;
233
- name: string;
234
- isUniversal: boolean;
235
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
236
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
237
- offset: (ts: number) => number;
238
- equals: (other: import("luxon").Zone) => boolean;
239
- isValid: boolean;
240
- };
241
- zoneName: string | null;
242
- year: number;
243
- quarter: number;
244
- month: number;
245
- day: number;
246
- hour: number;
247
- minute: number;
248
- second: number;
249
- millisecond: number;
250
- weekYear: number;
251
- weekNumber: number;
252
- weekday: number;
253
- isWeekend: boolean;
254
- localWeekday: number;
255
- localWeekNumber: number;
256
- localWeekYear: number;
257
- ordinal: number;
258
- monthShort: string | null;
259
- monthLong: string | null;
260
- weekdayShort: string | null;
261
- weekdayLong: string | null;
262
- offset: number;
263
- offsetNameShort: string | null;
264
- offsetNameLong: string | null;
265
- isOffsetFixed: boolean | null;
266
- isInDST: boolean;
267
- isInLeapYear: boolean;
268
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
269
- daysInYear: number;
270
- weeksInWeekYear: number;
271
- weeksInLocalWeekYear: number;
272
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
273
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
274
- toLocal: () => DateTime<boolean>;
275
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
276
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
277
- setLocale: (locale: string) => DateTime<boolean>;
278
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
279
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
280
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
281
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
282
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
283
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
284
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
285
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
286
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
287
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
288
- toISOWeekDate: () => string | null;
289
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
290
- toRFC2822: () => string | null;
291
- toHTTP: () => string | null;
292
- toSQLDate: () => string | null;
293
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
294
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
295
- toString: () => string;
296
- valueOf: () => number;
297
- toMillis: () => number;
298
- toSeconds: () => number;
299
- toUnixInteger: () => number;
300
- toJSON: () => string | null;
301
- toBSON: () => Date;
302
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
303
- includeConfig?: IncludeConfig | undefined;
304
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
305
- toJSDate: () => Date;
306
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
307
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
308
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
309
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
310
- equals: (other: DateTime) => boolean;
311
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
312
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
313
- } | null | undefined;
39
+ expiredAt?: string | null | undefined;
314
40
  } | null;
315
41
  processing: boolean;
316
42
  error: string | null;
@@ -341,284 +67,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
341
67
  packageItemId: string;
342
68
  eventId: string;
343
69
  name: string;
344
- startAt: {
345
- get: (unit: keyof DateTime) => number;
346
- getPossibleOffsets: () => DateTime<boolean>[];
347
- isValid: boolean;
348
- invalidReason: string | null;
349
- invalidExplanation: string | null;
350
- locale: string | null;
351
- numberingSystem: string | null;
352
- outputCalendar: string | null;
353
- zone: {
354
- type: string;
355
- name: string;
356
- isUniversal: boolean;
357
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
358
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
359
- offset: (ts: number) => number;
360
- equals: (other: import("luxon").Zone) => boolean;
361
- isValid: boolean;
362
- };
363
- zoneName: string | null;
364
- year: number;
365
- quarter: number;
366
- month: number;
367
- day: number;
368
- hour: number;
369
- minute: number;
370
- second: number;
371
- millisecond: number;
372
- weekYear: number;
373
- weekNumber: number;
374
- weekday: number;
375
- isWeekend: boolean;
376
- localWeekday: number;
377
- localWeekNumber: number;
378
- localWeekYear: number;
379
- ordinal: number;
380
- monthShort: string | null;
381
- monthLong: string | null;
382
- weekdayShort: string | null;
383
- weekdayLong: string | null;
384
- offset: number;
385
- offsetNameShort: string | null;
386
- offsetNameLong: string | null;
387
- isOffsetFixed: boolean | null;
388
- isInDST: boolean;
389
- isInLeapYear: boolean;
390
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
391
- daysInYear: number;
392
- weeksInWeekYear: number;
393
- weeksInLocalWeekYear: number;
394
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
395
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
396
- toLocal: () => DateTime<boolean>;
397
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
398
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
399
- setLocale: (locale: string) => DateTime<boolean>;
400
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
401
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
402
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
403
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
404
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
405
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
406
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
407
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
408
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
409
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
410
- toISOWeekDate: () => string | null;
411
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
412
- toRFC2822: () => string | null;
413
- toHTTP: () => string | null;
414
- toSQLDate: () => string | null;
415
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
416
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
417
- toString: () => string;
418
- valueOf: () => number;
419
- toMillis: () => number;
420
- toSeconds: () => number;
421
- toUnixInteger: () => number;
422
- toJSON: () => string | null;
423
- toBSON: () => Date;
424
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
425
- includeConfig?: IncludeConfig | undefined;
426
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
427
- toJSDate: () => Date;
428
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
429
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
430
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
431
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
432
- equals: (other: DateTime) => boolean;
433
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
434
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
435
- };
436
- endAt: {
437
- get: (unit: keyof DateTime) => number;
438
- getPossibleOffsets: () => DateTime<boolean>[];
439
- isValid: boolean;
440
- invalidReason: string | null;
441
- invalidExplanation: string | null;
442
- locale: string | null;
443
- numberingSystem: string | null;
444
- outputCalendar: string | null;
445
- zone: {
446
- type: string;
447
- name: string;
448
- isUniversal: boolean;
449
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
450
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
451
- offset: (ts: number) => number;
452
- equals: (other: import("luxon").Zone) => boolean;
453
- isValid: boolean;
454
- };
455
- zoneName: string | null;
456
- year: number;
457
- quarter: number;
458
- month: number;
459
- day: number;
460
- hour: number;
461
- minute: number;
462
- second: number;
463
- millisecond: number;
464
- weekYear: number;
465
- weekNumber: number;
466
- weekday: number;
467
- isWeekend: boolean;
468
- localWeekday: number;
469
- localWeekNumber: number;
470
- localWeekYear: number;
471
- ordinal: number;
472
- monthShort: string | null;
473
- monthLong: string | null;
474
- weekdayShort: string | null;
475
- weekdayLong: string | null;
476
- offset: number;
477
- offsetNameShort: string | null;
478
- offsetNameLong: string | null;
479
- isOffsetFixed: boolean | null;
480
- isInDST: boolean;
481
- isInLeapYear: boolean;
482
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
483
- daysInYear: number;
484
- weeksInWeekYear: number;
485
- weeksInLocalWeekYear: number;
486
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
487
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
488
- toLocal: () => DateTime<boolean>;
489
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
490
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
491
- setLocale: (locale: string) => DateTime<boolean>;
492
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
493
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
494
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
495
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
496
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
497
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
498
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
499
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
500
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
501
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
502
- toISOWeekDate: () => string | null;
503
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
504
- toRFC2822: () => string | null;
505
- toHTTP: () => string | null;
506
- toSQLDate: () => string | null;
507
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
508
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
509
- toString: () => string;
510
- valueOf: () => number;
511
- toMillis: () => number;
512
- toSeconds: () => number;
513
- toUnixInteger: () => number;
514
- toJSON: () => string | null;
515
- toBSON: () => Date;
516
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
517
- includeConfig?: IncludeConfig | undefined;
518
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
519
- toJSDate: () => Date;
520
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
521
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
522
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
523
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
524
- equals: (other: DateTime) => boolean;
525
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
526
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
527
- };
70
+ startAt: string;
71
+ endAt: string;
528
72
  }[] | undefined;
529
73
  }[];
530
- expiredAt?: {
531
- get: (unit: keyof DateTime) => number;
532
- getPossibleOffsets: () => DateTime<boolean>[];
533
- isValid: boolean;
534
- invalidReason: string | null;
535
- invalidExplanation: string | null;
536
- locale: string | null;
537
- numberingSystem: string | null;
538
- outputCalendar: string | null;
539
- zone: {
540
- type: string;
541
- name: string;
542
- isUniversal: boolean;
543
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
544
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
545
- offset: (ts: number) => number;
546
- equals: (other: import("luxon").Zone) => boolean;
547
- isValid: boolean;
548
- };
549
- zoneName: string | null;
550
- year: number;
551
- quarter: number;
552
- month: number;
553
- day: number;
554
- hour: number;
555
- minute: number;
556
- second: number;
557
- millisecond: number;
558
- weekYear: number;
559
- weekNumber: number;
560
- weekday: number;
561
- isWeekend: boolean;
562
- localWeekday: number;
563
- localWeekNumber: number;
564
- localWeekYear: number;
565
- ordinal: number;
566
- monthShort: string | null;
567
- monthLong: string | null;
568
- weekdayShort: string | null;
569
- weekdayLong: string | null;
570
- offset: number;
571
- offsetNameShort: string | null;
572
- offsetNameLong: string | null;
573
- isOffsetFixed: boolean | null;
574
- isInDST: boolean;
575
- isInLeapYear: boolean;
576
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
577
- daysInYear: number;
578
- weeksInWeekYear: number;
579
- weeksInLocalWeekYear: number;
580
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
581
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
582
- toLocal: () => DateTime<boolean>;
583
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
584
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
585
- setLocale: (locale: string) => DateTime<boolean>;
586
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
587
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
588
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
589
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
590
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
591
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
592
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
593
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
594
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
595
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
596
- toISOWeekDate: () => string | null;
597
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
598
- toRFC2822: () => string | null;
599
- toHTTP: () => string | null;
600
- toSQLDate: () => string | null;
601
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
602
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
603
- toString: () => string;
604
- valueOf: () => number;
605
- toMillis: () => number;
606
- toSeconds: () => number;
607
- toUnixInteger: () => number;
608
- toJSON: () => string | null;
609
- toBSON: () => Date;
610
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
611
- includeConfig?: IncludeConfig | undefined;
612
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
613
- toJSDate: () => Date;
614
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
615
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
616
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
617
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
618
- equals: (other: DateTime) => boolean;
619
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
620
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
621
- } | null | undefined;
74
+ expiredAt?: string | null | undefined;
622
75
  } | null;
623
76
  processing: boolean;
624
77
  error: string | null;
@@ -649,284 +102,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
649
102
  packageItemId: string;
650
103
  eventId: string;
651
104
  name: string;
652
- startAt: {
653
- get: (unit: keyof DateTime) => number;
654
- getPossibleOffsets: () => DateTime<boolean>[];
655
- isValid: boolean;
656
- invalidReason: string | null;
657
- invalidExplanation: string | null;
658
- locale: string | null;
659
- numberingSystem: string | null;
660
- outputCalendar: string | null;
661
- zone: {
662
- type: string;
663
- name: string;
664
- isUniversal: boolean;
665
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
666
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
667
- offset: (ts: number) => number;
668
- equals: (other: import("luxon").Zone) => boolean;
669
- isValid: boolean;
670
- };
671
- zoneName: string | null;
672
- year: number;
673
- quarter: number;
674
- month: number;
675
- day: number;
676
- hour: number;
677
- minute: number;
678
- second: number;
679
- millisecond: number;
680
- weekYear: number;
681
- weekNumber: number;
682
- weekday: number;
683
- isWeekend: boolean;
684
- localWeekday: number;
685
- localWeekNumber: number;
686
- localWeekYear: number;
687
- ordinal: number;
688
- monthShort: string | null;
689
- monthLong: string | null;
690
- weekdayShort: string | null;
691
- weekdayLong: string | null;
692
- offset: number;
693
- offsetNameShort: string | null;
694
- offsetNameLong: string | null;
695
- isOffsetFixed: boolean | null;
696
- isInDST: boolean;
697
- isInLeapYear: boolean;
698
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
699
- daysInYear: number;
700
- weeksInWeekYear: number;
701
- weeksInLocalWeekYear: number;
702
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
703
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
704
- toLocal: () => DateTime<boolean>;
705
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
706
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
707
- setLocale: (locale: string) => DateTime<boolean>;
708
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
709
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
710
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
711
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
712
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
713
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
714
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
715
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
716
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
717
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
718
- toISOWeekDate: () => string | null;
719
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
720
- toRFC2822: () => string | null;
721
- toHTTP: () => string | null;
722
- toSQLDate: () => string | null;
723
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
724
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
725
- toString: () => string;
726
- valueOf: () => number;
727
- toMillis: () => number;
728
- toSeconds: () => number;
729
- toUnixInteger: () => number;
730
- toJSON: () => string | null;
731
- toBSON: () => Date;
732
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
733
- includeConfig?: IncludeConfig | undefined;
734
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
735
- toJSDate: () => Date;
736
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
737
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
738
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
739
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
740
- equals: (other: DateTime) => boolean;
741
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
742
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
743
- };
744
- endAt: {
745
- get: (unit: keyof DateTime) => number;
746
- getPossibleOffsets: () => DateTime<boolean>[];
747
- isValid: boolean;
748
- invalidReason: string | null;
749
- invalidExplanation: string | null;
750
- locale: string | null;
751
- numberingSystem: string | null;
752
- outputCalendar: string | null;
753
- zone: {
754
- type: string;
755
- name: string;
756
- isUniversal: boolean;
757
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
758
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
759
- offset: (ts: number) => number;
760
- equals: (other: import("luxon").Zone) => boolean;
761
- isValid: boolean;
762
- };
763
- zoneName: string | null;
764
- year: number;
765
- quarter: number;
766
- month: number;
767
- day: number;
768
- hour: number;
769
- minute: number;
770
- second: number;
771
- millisecond: number;
772
- weekYear: number;
773
- weekNumber: number;
774
- weekday: number;
775
- isWeekend: boolean;
776
- localWeekday: number;
777
- localWeekNumber: number;
778
- localWeekYear: number;
779
- ordinal: number;
780
- monthShort: string | null;
781
- monthLong: string | null;
782
- weekdayShort: string | null;
783
- weekdayLong: string | null;
784
- offset: number;
785
- offsetNameShort: string | null;
786
- offsetNameLong: string | null;
787
- isOffsetFixed: boolean | null;
788
- isInDST: boolean;
789
- isInLeapYear: boolean;
790
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
791
- daysInYear: number;
792
- weeksInWeekYear: number;
793
- weeksInLocalWeekYear: number;
794
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
795
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
796
- toLocal: () => DateTime<boolean>;
797
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
798
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
799
- setLocale: (locale: string) => DateTime<boolean>;
800
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
801
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
802
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
803
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
804
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
805
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
806
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
807
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
808
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
809
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
810
- toISOWeekDate: () => string | null;
811
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
812
- toRFC2822: () => string | null;
813
- toHTTP: () => string | null;
814
- toSQLDate: () => string | null;
815
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
816
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
817
- toString: () => string;
818
- valueOf: () => number;
819
- toMillis: () => number;
820
- toSeconds: () => number;
821
- toUnixInteger: () => number;
822
- toJSON: () => string | null;
823
- toBSON: () => Date;
824
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
825
- includeConfig?: IncludeConfig | undefined;
826
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
827
- toJSDate: () => Date;
828
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
829
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
830
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
831
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
832
- equals: (other: DateTime) => boolean;
833
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
834
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
835
- };
105
+ startAt: string;
106
+ endAt: string;
836
107
  }[] | undefined;
837
108
  }[];
838
- expiredAt?: {
839
- get: (unit: keyof DateTime) => number;
840
- getPossibleOffsets: () => DateTime<boolean>[];
841
- isValid: boolean;
842
- invalidReason: string | null;
843
- invalidExplanation: string | null;
844
- locale: string | null;
845
- numberingSystem: string | null;
846
- outputCalendar: string | null;
847
- zone: {
848
- type: string;
849
- name: string;
850
- isUniversal: boolean;
851
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
852
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
853
- offset: (ts: number) => number;
854
- equals: (other: import("luxon").Zone) => boolean;
855
- isValid: boolean;
856
- };
857
- zoneName: string | null;
858
- year: number;
859
- quarter: number;
860
- month: number;
861
- day: number;
862
- hour: number;
863
- minute: number;
864
- second: number;
865
- millisecond: number;
866
- weekYear: number;
867
- weekNumber: number;
868
- weekday: number;
869
- isWeekend: boolean;
870
- localWeekday: number;
871
- localWeekNumber: number;
872
- localWeekYear: number;
873
- ordinal: number;
874
- monthShort: string | null;
875
- monthLong: string | null;
876
- weekdayShort: string | null;
877
- weekdayLong: string | null;
878
- offset: number;
879
- offsetNameShort: string | null;
880
- offsetNameLong: string | null;
881
- isOffsetFixed: boolean | null;
882
- isInDST: boolean;
883
- isInLeapYear: boolean;
884
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
885
- daysInYear: number;
886
- weeksInWeekYear: number;
887
- weeksInLocalWeekYear: number;
888
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
889
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
890
- toLocal: () => DateTime<boolean>;
891
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
892
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
893
- setLocale: (locale: string) => DateTime<boolean>;
894
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
895
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
896
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
897
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
898
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
899
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
900
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
901
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
902
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
903
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
904
- toISOWeekDate: () => string | null;
905
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
906
- toRFC2822: () => string | null;
907
- toHTTP: () => string | null;
908
- toSQLDate: () => string | null;
909
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
910
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
911
- toString: () => string;
912
- valueOf: () => number;
913
- toMillis: () => number;
914
- toSeconds: () => number;
915
- toUnixInteger: () => number;
916
- toJSON: () => string | null;
917
- toBSON: () => Date;
918
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
919
- includeConfig?: IncludeConfig | undefined;
920
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
921
- toJSDate: () => Date;
922
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
923
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
924
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
925
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
926
- equals: (other: DateTime) => boolean;
927
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
928
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
929
- } | null | undefined;
109
+ expiredAt?: string | null | undefined;
930
110
  } | null;
931
111
  processing: boolean;
932
112
  error: string | null;
@@ -957,291 +137,18 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
957
137
  packageItemId: string;
958
138
  eventId: string;
959
139
  name: string;
960
- startAt: {
961
- get: (unit: keyof DateTime) => number;
962
- getPossibleOffsets: () => DateTime<boolean>[];
963
- isValid: boolean;
964
- invalidReason: string | null;
965
- invalidExplanation: string | null;
966
- locale: string | null;
967
- numberingSystem: string | null;
968
- outputCalendar: string | null;
969
- zone: {
970
- type: string;
971
- name: string;
972
- isUniversal: boolean;
973
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
974
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
975
- offset: (ts: number) => number;
976
- equals: (other: import("luxon").Zone) => boolean;
977
- isValid: boolean;
978
- };
979
- zoneName: string | null;
980
- year: number;
981
- quarter: number;
982
- month: number;
983
- day: number;
984
- hour: number;
985
- minute: number;
986
- second: number;
987
- millisecond: number;
988
- weekYear: number;
989
- weekNumber: number;
990
- weekday: number;
991
- isWeekend: boolean;
992
- localWeekday: number;
993
- localWeekNumber: number;
994
- localWeekYear: number;
995
- ordinal: number;
996
- monthShort: string | null;
997
- monthLong: string | null;
998
- weekdayShort: string | null;
999
- weekdayLong: string | null;
1000
- offset: number;
1001
- offsetNameShort: string | null;
1002
- offsetNameLong: string | null;
1003
- isOffsetFixed: boolean | null;
1004
- isInDST: boolean;
1005
- isInLeapYear: boolean;
1006
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1007
- daysInYear: number;
1008
- weeksInWeekYear: number;
1009
- weeksInLocalWeekYear: number;
1010
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1011
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1012
- toLocal: () => DateTime<boolean>;
1013
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1014
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1015
- setLocale: (locale: string) => DateTime<boolean>;
1016
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1017
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1018
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1019
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1020
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1021
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1022
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1023
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1024
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1025
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1026
- toISOWeekDate: () => string | null;
1027
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1028
- toRFC2822: () => string | null;
1029
- toHTTP: () => string | null;
1030
- toSQLDate: () => string | null;
1031
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1032
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1033
- toString: () => string;
1034
- valueOf: () => number;
1035
- toMillis: () => number;
1036
- toSeconds: () => number;
1037
- toUnixInteger: () => number;
1038
- toJSON: () => string | null;
1039
- toBSON: () => Date;
1040
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1041
- includeConfig?: IncludeConfig | undefined;
1042
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1043
- toJSDate: () => Date;
1044
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1045
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1046
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1047
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1048
- equals: (other: DateTime) => boolean;
1049
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1050
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1051
- };
1052
- endAt: {
1053
- get: (unit: keyof DateTime) => number;
1054
- getPossibleOffsets: () => DateTime<boolean>[];
1055
- isValid: boolean;
1056
- invalidReason: string | null;
1057
- invalidExplanation: string | null;
1058
- locale: string | null;
1059
- numberingSystem: string | null;
1060
- outputCalendar: string | null;
1061
- zone: {
1062
- type: string;
1063
- name: string;
1064
- isUniversal: boolean;
1065
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1066
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1067
- offset: (ts: number) => number;
1068
- equals: (other: import("luxon").Zone) => boolean;
1069
- isValid: boolean;
1070
- };
1071
- zoneName: string | null;
1072
- year: number;
1073
- quarter: number;
1074
- month: number;
1075
- day: number;
1076
- hour: number;
1077
- minute: number;
1078
- second: number;
1079
- millisecond: number;
1080
- weekYear: number;
1081
- weekNumber: number;
1082
- weekday: number;
1083
- isWeekend: boolean;
1084
- localWeekday: number;
1085
- localWeekNumber: number;
1086
- localWeekYear: number;
1087
- ordinal: number;
1088
- monthShort: string | null;
1089
- monthLong: string | null;
1090
- weekdayShort: string | null;
1091
- weekdayLong: string | null;
1092
- offset: number;
1093
- offsetNameShort: string | null;
1094
- offsetNameLong: string | null;
1095
- isOffsetFixed: boolean | null;
1096
- isInDST: boolean;
1097
- isInLeapYear: boolean;
1098
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1099
- daysInYear: number;
1100
- weeksInWeekYear: number;
1101
- weeksInLocalWeekYear: number;
1102
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1103
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1104
- toLocal: () => DateTime<boolean>;
1105
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1106
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1107
- setLocale: (locale: string) => DateTime<boolean>;
1108
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1109
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1110
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1111
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1112
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1113
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1114
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1115
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1116
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1117
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1118
- toISOWeekDate: () => string | null;
1119
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1120
- toRFC2822: () => string | null;
1121
- toHTTP: () => string | null;
1122
- toSQLDate: () => string | null;
1123
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1124
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1125
- toString: () => string;
1126
- valueOf: () => number;
1127
- toMillis: () => number;
1128
- toSeconds: () => number;
1129
- toUnixInteger: () => number;
1130
- toJSON: () => string | null;
1131
- toBSON: () => Date;
1132
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1133
- includeConfig?: IncludeConfig | undefined;
1134
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1135
- toJSDate: () => Date;
1136
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1137
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1138
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1139
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1140
- equals: (other: DateTime) => boolean;
1141
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1142
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1143
- };
140
+ startAt: string;
141
+ endAt: string;
1144
142
  }[] | undefined;
1145
143
  }[];
1146
- expiredAt?: {
1147
- get: (unit: keyof DateTime) => number;
1148
- getPossibleOffsets: () => DateTime<boolean>[];
1149
- isValid: boolean;
1150
- invalidReason: string | null;
1151
- invalidExplanation: string | null;
1152
- locale: string | null;
1153
- numberingSystem: string | null;
1154
- outputCalendar: string | null;
1155
- zone: {
1156
- type: string;
1157
- name: string;
1158
- isUniversal: boolean;
1159
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1160
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1161
- offset: (ts: number) => number;
1162
- equals: (other: import("luxon").Zone) => boolean;
1163
- isValid: boolean;
1164
- };
1165
- zoneName: string | null;
1166
- year: number;
1167
- quarter: number;
1168
- month: number;
1169
- day: number;
1170
- hour: number;
1171
- minute: number;
1172
- second: number;
1173
- millisecond: number;
1174
- weekYear: number;
1175
- weekNumber: number;
1176
- weekday: number;
1177
- isWeekend: boolean;
1178
- localWeekday: number;
1179
- localWeekNumber: number;
1180
- localWeekYear: number;
1181
- ordinal: number;
1182
- monthShort: string | null;
1183
- monthLong: string | null;
1184
- weekdayShort: string | null;
1185
- weekdayLong: string | null;
1186
- offset: number;
1187
- offsetNameShort: string | null;
1188
- offsetNameLong: string | null;
1189
- isOffsetFixed: boolean | null;
1190
- isInDST: boolean;
1191
- isInLeapYear: boolean;
1192
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1193
- daysInYear: number;
1194
- weeksInWeekYear: number;
1195
- weeksInLocalWeekYear: number;
1196
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1197
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1198
- toLocal: () => DateTime<boolean>;
1199
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1200
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1201
- setLocale: (locale: string) => DateTime<boolean>;
1202
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1203
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1204
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1205
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1206
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1207
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1208
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1209
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1210
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1211
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1212
- toISOWeekDate: () => string | null;
1213
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1214
- toRFC2822: () => string | null;
1215
- toHTTP: () => string | null;
1216
- toSQLDate: () => string | null;
1217
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1218
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1219
- toString: () => string;
1220
- valueOf: () => number;
1221
- toMillis: () => number;
1222
- toSeconds: () => number;
1223
- toUnixInteger: () => number;
1224
- toJSON: () => string | null;
1225
- toBSON: () => Date;
1226
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1227
- includeConfig?: IncludeConfig | undefined;
1228
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1229
- toJSDate: () => Date;
1230
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1231
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1232
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1233
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1234
- equals: (other: DateTime) => boolean;
1235
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1236
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1237
- } | null | undefined;
144
+ expiredAt?: string | null | undefined;
1238
145
  } | null;
1239
146
  processing: boolean;
1240
147
  error: string | null;
1241
148
  }, action: PayloadAction<{
1242
149
  id: string;
1243
150
  currency: Currency;
1244
- expiredAt?: DateTime | null;
151
+ expiredAt?: string | null;
1245
152
  }>) => void;
1246
153
  addProduct: (state: {
1247
154
  order: {
@@ -1269,291 +176,18 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
1269
176
  packageItemId: string;
1270
177
  eventId: string;
1271
178
  name: string;
1272
- startAt: {
1273
- get: (unit: keyof DateTime) => number;
1274
- getPossibleOffsets: () => DateTime<boolean>[];
1275
- isValid: boolean;
1276
- invalidReason: string | null;
1277
- invalidExplanation: string | null;
1278
- locale: string | null;
1279
- numberingSystem: string | null;
1280
- outputCalendar: string | null;
1281
- zone: {
1282
- type: string;
1283
- name: string;
1284
- isUniversal: boolean;
1285
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1286
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1287
- offset: (ts: number) => number;
1288
- equals: (other: import("luxon").Zone) => boolean;
1289
- isValid: boolean;
1290
- };
1291
- zoneName: string | null;
1292
- year: number;
1293
- quarter: number;
1294
- month: number;
1295
- day: number;
1296
- hour: number;
1297
- minute: number;
1298
- second: number;
1299
- millisecond: number;
1300
- weekYear: number;
1301
- weekNumber: number;
1302
- weekday: number;
1303
- isWeekend: boolean;
1304
- localWeekday: number;
1305
- localWeekNumber: number;
1306
- localWeekYear: number;
1307
- ordinal: number;
1308
- monthShort: string | null;
1309
- monthLong: string | null;
1310
- weekdayShort: string | null;
1311
- weekdayLong: string | null;
1312
- offset: number;
1313
- offsetNameShort: string | null;
1314
- offsetNameLong: string | null;
1315
- isOffsetFixed: boolean | null;
1316
- isInDST: boolean;
1317
- isInLeapYear: boolean;
1318
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1319
- daysInYear: number;
1320
- weeksInWeekYear: number;
1321
- weeksInLocalWeekYear: number;
1322
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1323
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1324
- toLocal: () => DateTime<boolean>;
1325
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1326
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1327
- setLocale: (locale: string) => DateTime<boolean>;
1328
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1329
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1330
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1331
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1332
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1333
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1334
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1335
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1336
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1337
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1338
- toISOWeekDate: () => string | null;
1339
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1340
- toRFC2822: () => string | null;
1341
- toHTTP: () => string | null;
1342
- toSQLDate: () => string | null;
1343
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1344
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1345
- toString: () => string;
1346
- valueOf: () => number;
1347
- toMillis: () => number;
1348
- toSeconds: () => number;
1349
- toUnixInteger: () => number;
1350
- toJSON: () => string | null;
1351
- toBSON: () => Date;
1352
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1353
- includeConfig?: IncludeConfig | undefined;
1354
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1355
- toJSDate: () => Date;
1356
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1357
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1358
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1359
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1360
- equals: (other: DateTime) => boolean;
1361
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1362
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1363
- };
1364
- endAt: {
1365
- get: (unit: keyof DateTime) => number;
1366
- getPossibleOffsets: () => DateTime<boolean>[];
1367
- isValid: boolean;
1368
- invalidReason: string | null;
1369
- invalidExplanation: string | null;
1370
- locale: string | null;
1371
- numberingSystem: string | null;
1372
- outputCalendar: string | null;
1373
- zone: {
1374
- type: string;
1375
- name: string;
1376
- isUniversal: boolean;
1377
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1378
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1379
- offset: (ts: number) => number;
1380
- equals: (other: import("luxon").Zone) => boolean;
1381
- isValid: boolean;
1382
- };
1383
- zoneName: string | null;
1384
- year: number;
1385
- quarter: number;
1386
- month: number;
1387
- day: number;
1388
- hour: number;
1389
- minute: number;
1390
- second: number;
1391
- millisecond: number;
1392
- weekYear: number;
1393
- weekNumber: number;
1394
- weekday: number;
1395
- isWeekend: boolean;
1396
- localWeekday: number;
1397
- localWeekNumber: number;
1398
- localWeekYear: number;
1399
- ordinal: number;
1400
- monthShort: string | null;
1401
- monthLong: string | null;
1402
- weekdayShort: string | null;
1403
- weekdayLong: string | null;
1404
- offset: number;
1405
- offsetNameShort: string | null;
1406
- offsetNameLong: string | null;
1407
- isOffsetFixed: boolean | null;
1408
- isInDST: boolean;
1409
- isInLeapYear: boolean;
1410
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1411
- daysInYear: number;
1412
- weeksInWeekYear: number;
1413
- weeksInLocalWeekYear: number;
1414
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1415
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1416
- toLocal: () => DateTime<boolean>;
1417
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1418
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1419
- setLocale: (locale: string) => DateTime<boolean>;
1420
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1421
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1422
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1423
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1424
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1425
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1426
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1427
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1428
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1429
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1430
- toISOWeekDate: () => string | null;
1431
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1432
- toRFC2822: () => string | null;
1433
- toHTTP: () => string | null;
1434
- toSQLDate: () => string | null;
1435
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1436
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1437
- toString: () => string;
1438
- valueOf: () => number;
1439
- toMillis: () => number;
1440
- toSeconds: () => number;
1441
- toUnixInteger: () => number;
1442
- toJSON: () => string | null;
1443
- toBSON: () => Date;
1444
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1445
- includeConfig?: IncludeConfig | undefined;
1446
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1447
- toJSDate: () => Date;
1448
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1449
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1450
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1451
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1452
- equals: (other: DateTime) => boolean;
1453
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1454
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1455
- };
179
+ startAt: string;
180
+ endAt: string;
1456
181
  }[] | undefined;
1457
182
  }[];
1458
- expiredAt?: {
1459
- get: (unit: keyof DateTime) => number;
1460
- getPossibleOffsets: () => DateTime<boolean>[];
1461
- isValid: boolean;
1462
- invalidReason: string | null;
1463
- invalidExplanation: string | null;
1464
- locale: string | null;
1465
- numberingSystem: string | null;
1466
- outputCalendar: string | null;
1467
- zone: {
1468
- type: string;
1469
- name: string;
1470
- isUniversal: boolean;
1471
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1472
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1473
- offset: (ts: number) => number;
1474
- equals: (other: import("luxon").Zone) => boolean;
1475
- isValid: boolean;
1476
- };
1477
- zoneName: string | null;
1478
- year: number;
1479
- quarter: number;
1480
- month: number;
1481
- day: number;
1482
- hour: number;
1483
- minute: number;
1484
- second: number;
1485
- millisecond: number;
1486
- weekYear: number;
1487
- weekNumber: number;
1488
- weekday: number;
1489
- isWeekend: boolean;
1490
- localWeekday: number;
1491
- localWeekNumber: number;
1492
- localWeekYear: number;
1493
- ordinal: number;
1494
- monthShort: string | null;
1495
- monthLong: string | null;
1496
- weekdayShort: string | null;
1497
- weekdayLong: string | null;
1498
- offset: number;
1499
- offsetNameShort: string | null;
1500
- offsetNameLong: string | null;
1501
- isOffsetFixed: boolean | null;
1502
- isInDST: boolean;
1503
- isInLeapYear: boolean;
1504
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1505
- daysInYear: number;
1506
- weeksInWeekYear: number;
1507
- weeksInLocalWeekYear: number;
1508
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1509
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1510
- toLocal: () => DateTime<boolean>;
1511
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1512
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1513
- setLocale: (locale: string) => DateTime<boolean>;
1514
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1515
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1516
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1517
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1518
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1519
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1520
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1521
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1522
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1523
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1524
- toISOWeekDate: () => string | null;
1525
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1526
- toRFC2822: () => string | null;
1527
- toHTTP: () => string | null;
1528
- toSQLDate: () => string | null;
1529
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1530
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1531
- toString: () => string;
1532
- valueOf: () => number;
1533
- toMillis: () => number;
1534
- toSeconds: () => number;
1535
- toUnixInteger: () => number;
1536
- toJSON: () => string | null;
1537
- toBSON: () => Date;
1538
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1539
- includeConfig?: IncludeConfig | undefined;
1540
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1541
- toJSDate: () => Date;
1542
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1543
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1544
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1545
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1546
- equals: (other: DateTime) => boolean;
1547
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1548
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1549
- } | null | undefined;
183
+ expiredAt?: string | null | undefined;
1550
184
  } | null;
1551
185
  processing: boolean;
1552
186
  error: string | null;
1553
187
  }, action: PayloadAction<{
1554
188
  input: ProductInput;
1555
189
  amountReserved: number;
1556
- expiredAt?: DateTime | null;
190
+ expiredAt?: string | null;
1557
191
  }>) => void;
1558
192
  removeProduct: (state: {
1559
193
  order: {
@@ -1581,284 +215,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
1581
215
  packageItemId: string;
1582
216
  eventId: string;
1583
217
  name: string;
1584
- startAt: {
1585
- get: (unit: keyof DateTime) => number;
1586
- getPossibleOffsets: () => DateTime<boolean>[];
1587
- isValid: boolean;
1588
- invalidReason: string | null;
1589
- invalidExplanation: string | null;
1590
- locale: string | null;
1591
- numberingSystem: string | null;
1592
- outputCalendar: string | null;
1593
- zone: {
1594
- type: string;
1595
- name: string;
1596
- isUniversal: boolean;
1597
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1598
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1599
- offset: (ts: number) => number;
1600
- equals: (other: import("luxon").Zone) => boolean;
1601
- isValid: boolean;
1602
- };
1603
- zoneName: string | null;
1604
- year: number;
1605
- quarter: number;
1606
- month: number;
1607
- day: number;
1608
- hour: number;
1609
- minute: number;
1610
- second: number;
1611
- millisecond: number;
1612
- weekYear: number;
1613
- weekNumber: number;
1614
- weekday: number;
1615
- isWeekend: boolean;
1616
- localWeekday: number;
1617
- localWeekNumber: number;
1618
- localWeekYear: number;
1619
- ordinal: number;
1620
- monthShort: string | null;
1621
- monthLong: string | null;
1622
- weekdayShort: string | null;
1623
- weekdayLong: string | null;
1624
- offset: number;
1625
- offsetNameShort: string | null;
1626
- offsetNameLong: string | null;
1627
- isOffsetFixed: boolean | null;
1628
- isInDST: boolean;
1629
- isInLeapYear: boolean;
1630
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1631
- daysInYear: number;
1632
- weeksInWeekYear: number;
1633
- weeksInLocalWeekYear: number;
1634
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1635
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1636
- toLocal: () => DateTime<boolean>;
1637
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1638
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1639
- setLocale: (locale: string) => DateTime<boolean>;
1640
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1641
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1642
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1643
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1644
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1645
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1646
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1647
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1648
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1649
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1650
- toISOWeekDate: () => string | null;
1651
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1652
- toRFC2822: () => string | null;
1653
- toHTTP: () => string | null;
1654
- toSQLDate: () => string | null;
1655
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1656
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1657
- toString: () => string;
1658
- valueOf: () => number;
1659
- toMillis: () => number;
1660
- toSeconds: () => number;
1661
- toUnixInteger: () => number;
1662
- toJSON: () => string | null;
1663
- toBSON: () => Date;
1664
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1665
- includeConfig?: IncludeConfig | undefined;
1666
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1667
- toJSDate: () => Date;
1668
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1669
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1670
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1671
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1672
- equals: (other: DateTime) => boolean;
1673
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1674
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1675
- };
1676
- endAt: {
1677
- get: (unit: keyof DateTime) => number;
1678
- getPossibleOffsets: () => DateTime<boolean>[];
1679
- isValid: boolean;
1680
- invalidReason: string | null;
1681
- invalidExplanation: string | null;
1682
- locale: string | null;
1683
- numberingSystem: string | null;
1684
- outputCalendar: string | null;
1685
- zone: {
1686
- type: string;
1687
- name: string;
1688
- isUniversal: boolean;
1689
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1690
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1691
- offset: (ts: number) => number;
1692
- equals: (other: import("luxon").Zone) => boolean;
1693
- isValid: boolean;
1694
- };
1695
- zoneName: string | null;
1696
- year: number;
1697
- quarter: number;
1698
- month: number;
1699
- day: number;
1700
- hour: number;
1701
- minute: number;
1702
- second: number;
1703
- millisecond: number;
1704
- weekYear: number;
1705
- weekNumber: number;
1706
- weekday: number;
1707
- isWeekend: boolean;
1708
- localWeekday: number;
1709
- localWeekNumber: number;
1710
- localWeekYear: number;
1711
- ordinal: number;
1712
- monthShort: string | null;
1713
- monthLong: string | null;
1714
- weekdayShort: string | null;
1715
- weekdayLong: string | null;
1716
- offset: number;
1717
- offsetNameShort: string | null;
1718
- offsetNameLong: string | null;
1719
- isOffsetFixed: boolean | null;
1720
- isInDST: boolean;
1721
- isInLeapYear: boolean;
1722
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1723
- daysInYear: number;
1724
- weeksInWeekYear: number;
1725
- weeksInLocalWeekYear: number;
1726
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1727
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1728
- toLocal: () => DateTime<boolean>;
1729
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1730
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1731
- setLocale: (locale: string) => DateTime<boolean>;
1732
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1733
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1734
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1735
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1736
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1737
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1738
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1739
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1740
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1741
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1742
- toISOWeekDate: () => string | null;
1743
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1744
- toRFC2822: () => string | null;
1745
- toHTTP: () => string | null;
1746
- toSQLDate: () => string | null;
1747
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1748
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1749
- toString: () => string;
1750
- valueOf: () => number;
1751
- toMillis: () => number;
1752
- toSeconds: () => number;
1753
- toUnixInteger: () => number;
1754
- toJSON: () => string | null;
1755
- toBSON: () => Date;
1756
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1757
- includeConfig?: IncludeConfig | undefined;
1758
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1759
- toJSDate: () => Date;
1760
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1761
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1762
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1763
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1764
- equals: (other: DateTime) => boolean;
1765
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1766
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1767
- };
218
+ startAt: string;
219
+ endAt: string;
1768
220
  }[] | undefined;
1769
221
  }[];
1770
- expiredAt?: {
1771
- get: (unit: keyof DateTime) => number;
1772
- getPossibleOffsets: () => DateTime<boolean>[];
1773
- isValid: boolean;
1774
- invalidReason: string | null;
1775
- invalidExplanation: string | null;
1776
- locale: string | null;
1777
- numberingSystem: string | null;
1778
- outputCalendar: string | null;
1779
- zone: {
1780
- type: string;
1781
- name: string;
1782
- isUniversal: boolean;
1783
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1784
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1785
- offset: (ts: number) => number;
1786
- equals: (other: import("luxon").Zone) => boolean;
1787
- isValid: boolean;
1788
- };
1789
- zoneName: string | null;
1790
- year: number;
1791
- quarter: number;
1792
- month: number;
1793
- day: number;
1794
- hour: number;
1795
- minute: number;
1796
- second: number;
1797
- millisecond: number;
1798
- weekYear: number;
1799
- weekNumber: number;
1800
- weekday: number;
1801
- isWeekend: boolean;
1802
- localWeekday: number;
1803
- localWeekNumber: number;
1804
- localWeekYear: number;
1805
- ordinal: number;
1806
- monthShort: string | null;
1807
- monthLong: string | null;
1808
- weekdayShort: string | null;
1809
- weekdayLong: string | null;
1810
- offset: number;
1811
- offsetNameShort: string | null;
1812
- offsetNameLong: string | null;
1813
- isOffsetFixed: boolean | null;
1814
- isInDST: boolean;
1815
- isInLeapYear: boolean;
1816
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1817
- daysInYear: number;
1818
- weeksInWeekYear: number;
1819
- weeksInLocalWeekYear: number;
1820
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1821
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1822
- toLocal: () => DateTime<boolean>;
1823
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1824
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1825
- setLocale: (locale: string) => DateTime<boolean>;
1826
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1827
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1828
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1829
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1830
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1831
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1832
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1833
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1834
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1835
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1836
- toISOWeekDate: () => string | null;
1837
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1838
- toRFC2822: () => string | null;
1839
- toHTTP: () => string | null;
1840
- toSQLDate: () => string | null;
1841
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1842
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1843
- toString: () => string;
1844
- valueOf: () => number;
1845
- toMillis: () => number;
1846
- toSeconds: () => number;
1847
- toUnixInteger: () => number;
1848
- toJSON: () => string | null;
1849
- toBSON: () => Date;
1850
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1851
- includeConfig?: IncludeConfig | undefined;
1852
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1853
- toJSDate: () => Date;
1854
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1855
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1856
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1857
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1858
- equals: (other: DateTime) => boolean;
1859
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1860
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1861
- } | null | undefined;
222
+ expiredAt?: string | null | undefined;
1862
223
  } | null;
1863
224
  processing: boolean;
1864
225
  error: string | null;
@@ -1893,291 +254,18 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
1893
254
  packageItemId: string;
1894
255
  eventId: string;
1895
256
  name: string;
1896
- startAt: {
1897
- get: (unit: keyof DateTime) => number;
1898
- getPossibleOffsets: () => DateTime<boolean>[];
1899
- isValid: boolean;
1900
- invalidReason: string | null;
1901
- invalidExplanation: string | null;
1902
- locale: string | null;
1903
- numberingSystem: string | null;
1904
- outputCalendar: string | null;
1905
- zone: {
1906
- type: string;
1907
- name: string;
1908
- isUniversal: boolean;
1909
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
1910
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
1911
- offset: (ts: number) => number;
1912
- equals: (other: import("luxon").Zone) => boolean;
1913
- isValid: boolean;
1914
- };
1915
- zoneName: string | null;
1916
- year: number;
1917
- quarter: number;
1918
- month: number;
1919
- day: number;
1920
- hour: number;
1921
- minute: number;
1922
- second: number;
1923
- millisecond: number;
1924
- weekYear: number;
1925
- weekNumber: number;
1926
- weekday: number;
1927
- isWeekend: boolean;
1928
- localWeekday: number;
1929
- localWeekNumber: number;
1930
- localWeekYear: number;
1931
- ordinal: number;
1932
- monthShort: string | null;
1933
- monthLong: string | null;
1934
- weekdayShort: string | null;
1935
- weekdayLong: string | null;
1936
- offset: number;
1937
- offsetNameShort: string | null;
1938
- offsetNameLong: string | null;
1939
- isOffsetFixed: boolean | null;
1940
- isInDST: boolean;
1941
- isInLeapYear: boolean;
1942
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
1943
- daysInYear: number;
1944
- weeksInWeekYear: number;
1945
- weeksInLocalWeekYear: number;
1946
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
1947
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
1948
- toLocal: () => DateTime<boolean>;
1949
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
1950
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
1951
- setLocale: (locale: string) => DateTime<boolean>;
1952
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
1953
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1954
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
1955
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
1956
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
1957
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
1958
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
1959
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
1960
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1961
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
1962
- toISOWeekDate: () => string | null;
1963
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
1964
- toRFC2822: () => string | null;
1965
- toHTTP: () => string | null;
1966
- toSQLDate: () => string | null;
1967
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
1968
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
1969
- toString: () => string;
1970
- valueOf: () => number;
1971
- toMillis: () => number;
1972
- toSeconds: () => number;
1973
- toUnixInteger: () => number;
1974
- toJSON: () => string | null;
1975
- toBSON: () => Date;
1976
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
1977
- includeConfig?: IncludeConfig | undefined;
1978
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
1979
- toJSDate: () => Date;
1980
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
1981
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
1982
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
1983
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
1984
- equals: (other: DateTime) => boolean;
1985
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
1986
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
1987
- };
1988
- endAt: {
1989
- get: (unit: keyof DateTime) => number;
1990
- getPossibleOffsets: () => DateTime<boolean>[];
1991
- isValid: boolean;
1992
- invalidReason: string | null;
1993
- invalidExplanation: string | null;
1994
- locale: string | null;
1995
- numberingSystem: string | null;
1996
- outputCalendar: string | null;
1997
- zone: {
1998
- type: string;
1999
- name: string;
2000
- isUniversal: boolean;
2001
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2002
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2003
- offset: (ts: number) => number;
2004
- equals: (other: import("luxon").Zone) => boolean;
2005
- isValid: boolean;
2006
- };
2007
- zoneName: string | null;
2008
- year: number;
2009
- quarter: number;
2010
- month: number;
2011
- day: number;
2012
- hour: number;
2013
- minute: number;
2014
- second: number;
2015
- millisecond: number;
2016
- weekYear: number;
2017
- weekNumber: number;
2018
- weekday: number;
2019
- isWeekend: boolean;
2020
- localWeekday: number;
2021
- localWeekNumber: number;
2022
- localWeekYear: number;
2023
- ordinal: number;
2024
- monthShort: string | null;
2025
- monthLong: string | null;
2026
- weekdayShort: string | null;
2027
- weekdayLong: string | null;
2028
- offset: number;
2029
- offsetNameShort: string | null;
2030
- offsetNameLong: string | null;
2031
- isOffsetFixed: boolean | null;
2032
- isInDST: boolean;
2033
- isInLeapYear: boolean;
2034
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2035
- daysInYear: number;
2036
- weeksInWeekYear: number;
2037
- weeksInLocalWeekYear: number;
2038
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2039
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2040
- toLocal: () => DateTime<boolean>;
2041
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2042
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2043
- setLocale: (locale: string) => DateTime<boolean>;
2044
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2045
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2046
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2047
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2048
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2049
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2050
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2051
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2052
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2053
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2054
- toISOWeekDate: () => string | null;
2055
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2056
- toRFC2822: () => string | null;
2057
- toHTTP: () => string | null;
2058
- toSQLDate: () => string | null;
2059
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2060
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2061
- toString: () => string;
2062
- valueOf: () => number;
2063
- toMillis: () => number;
2064
- toSeconds: () => number;
2065
- toUnixInteger: () => number;
2066
- toJSON: () => string | null;
2067
- toBSON: () => Date;
2068
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2069
- includeConfig?: IncludeConfig | undefined;
2070
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2071
- toJSDate: () => Date;
2072
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2073
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2074
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2075
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2076
- equals: (other: DateTime) => boolean;
2077
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2078
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2079
- };
257
+ startAt: string;
258
+ endAt: string;
2080
259
  }[] | undefined;
2081
260
  }[];
2082
- expiredAt?: {
2083
- get: (unit: keyof DateTime) => number;
2084
- getPossibleOffsets: () => DateTime<boolean>[];
2085
- isValid: boolean;
2086
- invalidReason: string | null;
2087
- invalidExplanation: string | null;
2088
- locale: string | null;
2089
- numberingSystem: string | null;
2090
- outputCalendar: string | null;
2091
- zone: {
2092
- type: string;
2093
- name: string;
2094
- isUniversal: boolean;
2095
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2096
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2097
- offset: (ts: number) => number;
2098
- equals: (other: import("luxon").Zone) => boolean;
2099
- isValid: boolean;
2100
- };
2101
- zoneName: string | null;
2102
- year: number;
2103
- quarter: number;
2104
- month: number;
2105
- day: number;
2106
- hour: number;
2107
- minute: number;
2108
- second: number;
2109
- millisecond: number;
2110
- weekYear: number;
2111
- weekNumber: number;
2112
- weekday: number;
2113
- isWeekend: boolean;
2114
- localWeekday: number;
2115
- localWeekNumber: number;
2116
- localWeekYear: number;
2117
- ordinal: number;
2118
- monthShort: string | null;
2119
- monthLong: string | null;
2120
- weekdayShort: string | null;
2121
- weekdayLong: string | null;
2122
- offset: number;
2123
- offsetNameShort: string | null;
2124
- offsetNameLong: string | null;
2125
- isOffsetFixed: boolean | null;
2126
- isInDST: boolean;
2127
- isInLeapYear: boolean;
2128
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2129
- daysInYear: number;
2130
- weeksInWeekYear: number;
2131
- weeksInLocalWeekYear: number;
2132
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2133
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2134
- toLocal: () => DateTime<boolean>;
2135
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2136
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2137
- setLocale: (locale: string) => DateTime<boolean>;
2138
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2139
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2140
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2141
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2142
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2143
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2144
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2145
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2146
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2147
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2148
- toISOWeekDate: () => string | null;
2149
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2150
- toRFC2822: () => string | null;
2151
- toHTTP: () => string | null;
2152
- toSQLDate: () => string | null;
2153
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2154
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2155
- toString: () => string;
2156
- valueOf: () => number;
2157
- toMillis: () => number;
2158
- toSeconds: () => number;
2159
- toUnixInteger: () => number;
2160
- toJSON: () => string | null;
2161
- toBSON: () => Date;
2162
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2163
- includeConfig?: IncludeConfig | undefined;
2164
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2165
- toJSDate: () => Date;
2166
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2167
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2168
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2169
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2170
- equals: (other: DateTime) => boolean;
2171
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2172
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2173
- } | null | undefined;
261
+ expiredAt?: string | null | undefined;
2174
262
  } | null;
2175
263
  processing: boolean;
2176
264
  error: string | null;
2177
265
  }, action: PayloadAction<{
2178
266
  input: ConfigurePackageInput;
2179
267
  amountReserved: number;
2180
- expiredAt?: DateTime | null;
268
+ expiredAt?: string | null;
2181
269
  }>) => void;
2182
270
  reserveAdditionalPackageItem: (state: {
2183
271
  order: {
@@ -2205,291 +293,18 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
2205
293
  packageItemId: string;
2206
294
  eventId: string;
2207
295
  name: string;
2208
- startAt: {
2209
- get: (unit: keyof DateTime) => number;
2210
- getPossibleOffsets: () => DateTime<boolean>[];
2211
- isValid: boolean;
2212
- invalidReason: string | null;
2213
- invalidExplanation: string | null;
2214
- locale: string | null;
2215
- numberingSystem: string | null;
2216
- outputCalendar: string | null;
2217
- zone: {
2218
- type: string;
2219
- name: string;
2220
- isUniversal: boolean;
2221
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2222
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2223
- offset: (ts: number) => number;
2224
- equals: (other: import("luxon").Zone) => boolean;
2225
- isValid: boolean;
2226
- };
2227
- zoneName: string | null;
2228
- year: number;
2229
- quarter: number;
2230
- month: number;
2231
- day: number;
2232
- hour: number;
2233
- minute: number;
2234
- second: number;
2235
- millisecond: number;
2236
- weekYear: number;
2237
- weekNumber: number;
2238
- weekday: number;
2239
- isWeekend: boolean;
2240
- localWeekday: number;
2241
- localWeekNumber: number;
2242
- localWeekYear: number;
2243
- ordinal: number;
2244
- monthShort: string | null;
2245
- monthLong: string | null;
2246
- weekdayShort: string | null;
2247
- weekdayLong: string | null;
2248
- offset: number;
2249
- offsetNameShort: string | null;
2250
- offsetNameLong: string | null;
2251
- isOffsetFixed: boolean | null;
2252
- isInDST: boolean;
2253
- isInLeapYear: boolean;
2254
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2255
- daysInYear: number;
2256
- weeksInWeekYear: number;
2257
- weeksInLocalWeekYear: number;
2258
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2259
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2260
- toLocal: () => DateTime<boolean>;
2261
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2262
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2263
- setLocale: (locale: string) => DateTime<boolean>;
2264
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2265
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2266
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2267
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2268
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2269
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2270
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2271
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2272
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2273
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2274
- toISOWeekDate: () => string | null;
2275
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2276
- toRFC2822: () => string | null;
2277
- toHTTP: () => string | null;
2278
- toSQLDate: () => string | null;
2279
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2280
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2281
- toString: () => string;
2282
- valueOf: () => number;
2283
- toMillis: () => number;
2284
- toSeconds: () => number;
2285
- toUnixInteger: () => number;
2286
- toJSON: () => string | null;
2287
- toBSON: () => Date;
2288
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2289
- includeConfig?: IncludeConfig | undefined;
2290
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2291
- toJSDate: () => Date;
2292
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2293
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2294
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2295
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2296
- equals: (other: DateTime) => boolean;
2297
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2298
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2299
- };
2300
- endAt: {
2301
- get: (unit: keyof DateTime) => number;
2302
- getPossibleOffsets: () => DateTime<boolean>[];
2303
- isValid: boolean;
2304
- invalidReason: string | null;
2305
- invalidExplanation: string | null;
2306
- locale: string | null;
2307
- numberingSystem: string | null;
2308
- outputCalendar: string | null;
2309
- zone: {
2310
- type: string;
2311
- name: string;
2312
- isUniversal: boolean;
2313
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2314
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2315
- offset: (ts: number) => number;
2316
- equals: (other: import("luxon").Zone) => boolean;
2317
- isValid: boolean;
2318
- };
2319
- zoneName: string | null;
2320
- year: number;
2321
- quarter: number;
2322
- month: number;
2323
- day: number;
2324
- hour: number;
2325
- minute: number;
2326
- second: number;
2327
- millisecond: number;
2328
- weekYear: number;
2329
- weekNumber: number;
2330
- weekday: number;
2331
- isWeekend: boolean;
2332
- localWeekday: number;
2333
- localWeekNumber: number;
2334
- localWeekYear: number;
2335
- ordinal: number;
2336
- monthShort: string | null;
2337
- monthLong: string | null;
2338
- weekdayShort: string | null;
2339
- weekdayLong: string | null;
2340
- offset: number;
2341
- offsetNameShort: string | null;
2342
- offsetNameLong: string | null;
2343
- isOffsetFixed: boolean | null;
2344
- isInDST: boolean;
2345
- isInLeapYear: boolean;
2346
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2347
- daysInYear: number;
2348
- weeksInWeekYear: number;
2349
- weeksInLocalWeekYear: number;
2350
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2351
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2352
- toLocal: () => DateTime<boolean>;
2353
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2354
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2355
- setLocale: (locale: string) => DateTime<boolean>;
2356
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2357
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2358
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2359
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2360
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2361
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2362
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2363
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2364
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2365
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2366
- toISOWeekDate: () => string | null;
2367
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2368
- toRFC2822: () => string | null;
2369
- toHTTP: () => string | null;
2370
- toSQLDate: () => string | null;
2371
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2372
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2373
- toString: () => string;
2374
- valueOf: () => number;
2375
- toMillis: () => number;
2376
- toSeconds: () => number;
2377
- toUnixInteger: () => number;
2378
- toJSON: () => string | null;
2379
- toBSON: () => Date;
2380
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2381
- includeConfig?: IncludeConfig | undefined;
2382
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2383
- toJSDate: () => Date;
2384
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2385
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2386
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2387
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2388
- equals: (other: DateTime) => boolean;
2389
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2390
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2391
- };
296
+ startAt: string;
297
+ endAt: string;
2392
298
  }[] | undefined;
2393
299
  }[];
2394
- expiredAt?: {
2395
- get: (unit: keyof DateTime) => number;
2396
- getPossibleOffsets: () => DateTime<boolean>[];
2397
- isValid: boolean;
2398
- invalidReason: string | null;
2399
- invalidExplanation: string | null;
2400
- locale: string | null;
2401
- numberingSystem: string | null;
2402
- outputCalendar: string | null;
2403
- zone: {
2404
- type: string;
2405
- name: string;
2406
- isUniversal: boolean;
2407
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2408
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2409
- offset: (ts: number) => number;
2410
- equals: (other: import("luxon").Zone) => boolean;
2411
- isValid: boolean;
2412
- };
2413
- zoneName: string | null;
2414
- year: number;
2415
- quarter: number;
2416
- month: number;
2417
- day: number;
2418
- hour: number;
2419
- minute: number;
2420
- second: number;
2421
- millisecond: number;
2422
- weekYear: number;
2423
- weekNumber: number;
2424
- weekday: number;
2425
- isWeekend: boolean;
2426
- localWeekday: number;
2427
- localWeekNumber: number;
2428
- localWeekYear: number;
2429
- ordinal: number;
2430
- monthShort: string | null;
2431
- monthLong: string | null;
2432
- weekdayShort: string | null;
2433
- weekdayLong: string | null;
2434
- offset: number;
2435
- offsetNameShort: string | null;
2436
- offsetNameLong: string | null;
2437
- isOffsetFixed: boolean | null;
2438
- isInDST: boolean;
2439
- isInLeapYear: boolean;
2440
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2441
- daysInYear: number;
2442
- weeksInWeekYear: number;
2443
- weeksInLocalWeekYear: number;
2444
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2445
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2446
- toLocal: () => DateTime<boolean>;
2447
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2448
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2449
- setLocale: (locale: string) => DateTime<boolean>;
2450
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2451
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2452
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2453
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2454
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2455
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2456
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2457
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2458
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2459
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2460
- toISOWeekDate: () => string | null;
2461
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2462
- toRFC2822: () => string | null;
2463
- toHTTP: () => string | null;
2464
- toSQLDate: () => string | null;
2465
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2466
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2467
- toString: () => string;
2468
- valueOf: () => number;
2469
- toMillis: () => number;
2470
- toSeconds: () => number;
2471
- toUnixInteger: () => number;
2472
- toJSON: () => string | null;
2473
- toBSON: () => Date;
2474
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2475
- includeConfig?: IncludeConfig | undefined;
2476
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2477
- toJSDate: () => Date;
2478
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2479
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2480
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2481
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2482
- equals: (other: DateTime) => boolean;
2483
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2484
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2485
- } | null | undefined;
300
+ expiredAt?: string | null | undefined;
2486
301
  } | null;
2487
302
  processing: boolean;
2488
303
  error: string | null;
2489
304
  }, action: PayloadAction<{
2490
305
  input: ReserveAdditionalPackageItemInput;
2491
306
  amountReserved: number;
2492
- expiredAt?: DateTime | null;
307
+ expiredAt?: string | null;
2493
308
  }>) => void;
2494
309
  configureDelivery: (state: {
2495
310
  order: {
@@ -2517,284 +332,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
2517
332
  packageItemId: string;
2518
333
  eventId: string;
2519
334
  name: string;
2520
- startAt: {
2521
- get: (unit: keyof DateTime) => number;
2522
- getPossibleOffsets: () => DateTime<boolean>[];
2523
- isValid: boolean;
2524
- invalidReason: string | null;
2525
- invalidExplanation: string | null;
2526
- locale: string | null;
2527
- numberingSystem: string | null;
2528
- outputCalendar: string | null;
2529
- zone: {
2530
- type: string;
2531
- name: string;
2532
- isUniversal: boolean;
2533
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2534
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2535
- offset: (ts: number) => number;
2536
- equals: (other: import("luxon").Zone) => boolean;
2537
- isValid: boolean;
2538
- };
2539
- zoneName: string | null;
2540
- year: number;
2541
- quarter: number;
2542
- month: number;
2543
- day: number;
2544
- hour: number;
2545
- minute: number;
2546
- second: number;
2547
- millisecond: number;
2548
- weekYear: number;
2549
- weekNumber: number;
2550
- weekday: number;
2551
- isWeekend: boolean;
2552
- localWeekday: number;
2553
- localWeekNumber: number;
2554
- localWeekYear: number;
2555
- ordinal: number;
2556
- monthShort: string | null;
2557
- monthLong: string | null;
2558
- weekdayShort: string | null;
2559
- weekdayLong: string | null;
2560
- offset: number;
2561
- offsetNameShort: string | null;
2562
- offsetNameLong: string | null;
2563
- isOffsetFixed: boolean | null;
2564
- isInDST: boolean;
2565
- isInLeapYear: boolean;
2566
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2567
- daysInYear: number;
2568
- weeksInWeekYear: number;
2569
- weeksInLocalWeekYear: number;
2570
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2571
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2572
- toLocal: () => DateTime<boolean>;
2573
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2574
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2575
- setLocale: (locale: string) => DateTime<boolean>;
2576
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2577
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2578
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2579
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2580
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2581
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2582
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2583
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2584
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2585
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2586
- toISOWeekDate: () => string | null;
2587
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2588
- toRFC2822: () => string | null;
2589
- toHTTP: () => string | null;
2590
- toSQLDate: () => string | null;
2591
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2592
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2593
- toString: () => string;
2594
- valueOf: () => number;
2595
- toMillis: () => number;
2596
- toSeconds: () => number;
2597
- toUnixInteger: () => number;
2598
- toJSON: () => string | null;
2599
- toBSON: () => Date;
2600
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2601
- includeConfig?: IncludeConfig | undefined;
2602
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2603
- toJSDate: () => Date;
2604
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2605
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2606
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2607
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2608
- equals: (other: DateTime) => boolean;
2609
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2610
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2611
- };
2612
- endAt: {
2613
- get: (unit: keyof DateTime) => number;
2614
- getPossibleOffsets: () => DateTime<boolean>[];
2615
- isValid: boolean;
2616
- invalidReason: string | null;
2617
- invalidExplanation: string | null;
2618
- locale: string | null;
2619
- numberingSystem: string | null;
2620
- outputCalendar: string | null;
2621
- zone: {
2622
- type: string;
2623
- name: string;
2624
- isUniversal: boolean;
2625
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2626
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2627
- offset: (ts: number) => number;
2628
- equals: (other: import("luxon").Zone) => boolean;
2629
- isValid: boolean;
2630
- };
2631
- zoneName: string | null;
2632
- year: number;
2633
- quarter: number;
2634
- month: number;
2635
- day: number;
2636
- hour: number;
2637
- minute: number;
2638
- second: number;
2639
- millisecond: number;
2640
- weekYear: number;
2641
- weekNumber: number;
2642
- weekday: number;
2643
- isWeekend: boolean;
2644
- localWeekday: number;
2645
- localWeekNumber: number;
2646
- localWeekYear: number;
2647
- ordinal: number;
2648
- monthShort: string | null;
2649
- monthLong: string | null;
2650
- weekdayShort: string | null;
2651
- weekdayLong: string | null;
2652
- offset: number;
2653
- offsetNameShort: string | null;
2654
- offsetNameLong: string | null;
2655
- isOffsetFixed: boolean | null;
2656
- isInDST: boolean;
2657
- isInLeapYear: boolean;
2658
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2659
- daysInYear: number;
2660
- weeksInWeekYear: number;
2661
- weeksInLocalWeekYear: number;
2662
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2663
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2664
- toLocal: () => DateTime<boolean>;
2665
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2666
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2667
- setLocale: (locale: string) => DateTime<boolean>;
2668
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2669
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2670
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2671
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2672
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2673
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2674
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2675
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2676
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2677
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2678
- toISOWeekDate: () => string | null;
2679
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2680
- toRFC2822: () => string | null;
2681
- toHTTP: () => string | null;
2682
- toSQLDate: () => string | null;
2683
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2684
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2685
- toString: () => string;
2686
- valueOf: () => number;
2687
- toMillis: () => number;
2688
- toSeconds: () => number;
2689
- toUnixInteger: () => number;
2690
- toJSON: () => string | null;
2691
- toBSON: () => Date;
2692
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2693
- includeConfig?: IncludeConfig | undefined;
2694
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2695
- toJSDate: () => Date;
2696
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2697
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2698
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2699
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2700
- equals: (other: DateTime) => boolean;
2701
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2702
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2703
- };
335
+ startAt: string;
336
+ endAt: string;
2704
337
  }[] | undefined;
2705
338
  }[];
2706
- expiredAt?: {
2707
- get: (unit: keyof DateTime) => number;
2708
- getPossibleOffsets: () => DateTime<boolean>[];
2709
- isValid: boolean;
2710
- invalidReason: string | null;
2711
- invalidExplanation: string | null;
2712
- locale: string | null;
2713
- numberingSystem: string | null;
2714
- outputCalendar: string | null;
2715
- zone: {
2716
- type: string;
2717
- name: string;
2718
- isUniversal: boolean;
2719
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2720
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2721
- offset: (ts: number) => number;
2722
- equals: (other: import("luxon").Zone) => boolean;
2723
- isValid: boolean;
2724
- };
2725
- zoneName: string | null;
2726
- year: number;
2727
- quarter: number;
2728
- month: number;
2729
- day: number;
2730
- hour: number;
2731
- minute: number;
2732
- second: number;
2733
- millisecond: number;
2734
- weekYear: number;
2735
- weekNumber: number;
2736
- weekday: number;
2737
- isWeekend: boolean;
2738
- localWeekday: number;
2739
- localWeekNumber: number;
2740
- localWeekYear: number;
2741
- ordinal: number;
2742
- monthShort: string | null;
2743
- monthLong: string | null;
2744
- weekdayShort: string | null;
2745
- weekdayLong: string | null;
2746
- offset: number;
2747
- offsetNameShort: string | null;
2748
- offsetNameLong: string | null;
2749
- isOffsetFixed: boolean | null;
2750
- isInDST: boolean;
2751
- isInLeapYear: boolean;
2752
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2753
- daysInYear: number;
2754
- weeksInWeekYear: number;
2755
- weeksInLocalWeekYear: number;
2756
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2757
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2758
- toLocal: () => DateTime<boolean>;
2759
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2760
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2761
- setLocale: (locale: string) => DateTime<boolean>;
2762
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2763
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2764
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2765
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2766
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2767
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2768
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2769
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2770
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2771
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2772
- toISOWeekDate: () => string | null;
2773
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2774
- toRFC2822: () => string | null;
2775
- toHTTP: () => string | null;
2776
- toSQLDate: () => string | null;
2777
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2778
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2779
- toString: () => string;
2780
- valueOf: () => number;
2781
- toMillis: () => number;
2782
- toSeconds: () => number;
2783
- toUnixInteger: () => number;
2784
- toJSON: () => string | null;
2785
- toBSON: () => Date;
2786
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2787
- includeConfig?: IncludeConfig | undefined;
2788
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2789
- toJSDate: () => Date;
2790
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2791
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2792
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2793
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2794
- equals: (other: DateTime) => boolean;
2795
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2796
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2797
- } | null | undefined;
339
+ expiredAt?: string | null | undefined;
2798
340
  } | null;
2799
341
  processing: boolean;
2800
342
  error: string | null;
@@ -2825,284 +367,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
2825
367
  packageItemId: string;
2826
368
  eventId: string;
2827
369
  name: string;
2828
- startAt: {
2829
- get: (unit: keyof DateTime) => number;
2830
- getPossibleOffsets: () => DateTime<boolean>[];
2831
- isValid: boolean;
2832
- invalidReason: string | null;
2833
- invalidExplanation: string | null;
2834
- locale: string | null;
2835
- numberingSystem: string | null;
2836
- outputCalendar: string | null;
2837
- zone: {
2838
- type: string;
2839
- name: string;
2840
- isUniversal: boolean;
2841
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2842
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2843
- offset: (ts: number) => number;
2844
- equals: (other: import("luxon").Zone) => boolean;
2845
- isValid: boolean;
2846
- };
2847
- zoneName: string | null;
2848
- year: number;
2849
- quarter: number;
2850
- month: number;
2851
- day: number;
2852
- hour: number;
2853
- minute: number;
2854
- second: number;
2855
- millisecond: number;
2856
- weekYear: number;
2857
- weekNumber: number;
2858
- weekday: number;
2859
- isWeekend: boolean;
2860
- localWeekday: number;
2861
- localWeekNumber: number;
2862
- localWeekYear: number;
2863
- ordinal: number;
2864
- monthShort: string | null;
2865
- monthLong: string | null;
2866
- weekdayShort: string | null;
2867
- weekdayLong: string | null;
2868
- offset: number;
2869
- offsetNameShort: string | null;
2870
- offsetNameLong: string | null;
2871
- isOffsetFixed: boolean | null;
2872
- isInDST: boolean;
2873
- isInLeapYear: boolean;
2874
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2875
- daysInYear: number;
2876
- weeksInWeekYear: number;
2877
- weeksInLocalWeekYear: number;
2878
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2879
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2880
- toLocal: () => DateTime<boolean>;
2881
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2882
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2883
- setLocale: (locale: string) => DateTime<boolean>;
2884
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2885
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2886
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2887
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2888
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2889
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2890
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2891
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2892
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2893
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2894
- toISOWeekDate: () => string | null;
2895
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2896
- toRFC2822: () => string | null;
2897
- toHTTP: () => string | null;
2898
- toSQLDate: () => string | null;
2899
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2900
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2901
- toString: () => string;
2902
- valueOf: () => number;
2903
- toMillis: () => number;
2904
- toSeconds: () => number;
2905
- toUnixInteger: () => number;
2906
- toJSON: () => string | null;
2907
- toBSON: () => Date;
2908
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
2909
- includeConfig?: IncludeConfig | undefined;
2910
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
2911
- toJSDate: () => Date;
2912
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
2913
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
2914
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
2915
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
2916
- equals: (other: DateTime) => boolean;
2917
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
2918
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
2919
- };
2920
- endAt: {
2921
- get: (unit: keyof DateTime) => number;
2922
- getPossibleOffsets: () => DateTime<boolean>[];
2923
- isValid: boolean;
2924
- invalidReason: string | null;
2925
- invalidExplanation: string | null;
2926
- locale: string | null;
2927
- numberingSystem: string | null;
2928
- outputCalendar: string | null;
2929
- zone: {
2930
- type: string;
2931
- name: string;
2932
- isUniversal: boolean;
2933
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
2934
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
2935
- offset: (ts: number) => number;
2936
- equals: (other: import("luxon").Zone) => boolean;
2937
- isValid: boolean;
2938
- };
2939
- zoneName: string | null;
2940
- year: number;
2941
- quarter: number;
2942
- month: number;
2943
- day: number;
2944
- hour: number;
2945
- minute: number;
2946
- second: number;
2947
- millisecond: number;
2948
- weekYear: number;
2949
- weekNumber: number;
2950
- weekday: number;
2951
- isWeekend: boolean;
2952
- localWeekday: number;
2953
- localWeekNumber: number;
2954
- localWeekYear: number;
2955
- ordinal: number;
2956
- monthShort: string | null;
2957
- monthLong: string | null;
2958
- weekdayShort: string | null;
2959
- weekdayLong: string | null;
2960
- offset: number;
2961
- offsetNameShort: string | null;
2962
- offsetNameLong: string | null;
2963
- isOffsetFixed: boolean | null;
2964
- isInDST: boolean;
2965
- isInLeapYear: boolean;
2966
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
2967
- daysInYear: number;
2968
- weeksInWeekYear: number;
2969
- weeksInLocalWeekYear: number;
2970
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
2971
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
2972
- toLocal: () => DateTime<boolean>;
2973
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
2974
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
2975
- setLocale: (locale: string) => DateTime<boolean>;
2976
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
2977
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2978
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
2979
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
2980
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
2981
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
2982
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
2983
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
2984
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2985
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
2986
- toISOWeekDate: () => string | null;
2987
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
2988
- toRFC2822: () => string | null;
2989
- toHTTP: () => string | null;
2990
- toSQLDate: () => string | null;
2991
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
2992
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
2993
- toString: () => string;
2994
- valueOf: () => number;
2995
- toMillis: () => number;
2996
- toSeconds: () => number;
2997
- toUnixInteger: () => number;
2998
- toJSON: () => string | null;
2999
- toBSON: () => Date;
3000
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
3001
- includeConfig?: IncludeConfig | undefined;
3002
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
3003
- toJSDate: () => Date;
3004
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
3005
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
3006
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
3007
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
3008
- equals: (other: DateTime) => boolean;
3009
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
3010
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
3011
- };
370
+ startAt: string;
371
+ endAt: string;
3012
372
  }[] | undefined;
3013
373
  }[];
3014
- expiredAt?: {
3015
- get: (unit: keyof DateTime) => number;
3016
- getPossibleOffsets: () => DateTime<boolean>[];
3017
- isValid: boolean;
3018
- invalidReason: string | null;
3019
- invalidExplanation: string | null;
3020
- locale: string | null;
3021
- numberingSystem: string | null;
3022
- outputCalendar: string | null;
3023
- zone: {
3024
- type: string;
3025
- name: string;
3026
- isUniversal: boolean;
3027
- offsetName: (ts: number, options: import("luxon").ZoneOffsetOptions) => string | null;
3028
- formatOffset: (ts: number, format: import("luxon").ZoneOffsetFormat) => string;
3029
- offset: (ts: number) => number;
3030
- equals: (other: import("luxon").Zone) => boolean;
3031
- isValid: boolean;
3032
- };
3033
- zoneName: string | null;
3034
- year: number;
3035
- quarter: number;
3036
- month: number;
3037
- day: number;
3038
- hour: number;
3039
- minute: number;
3040
- second: number;
3041
- millisecond: number;
3042
- weekYear: number;
3043
- weekNumber: number;
3044
- weekday: number;
3045
- isWeekend: boolean;
3046
- localWeekday: number;
3047
- localWeekNumber: number;
3048
- localWeekYear: number;
3049
- ordinal: number;
3050
- monthShort: string | null;
3051
- monthLong: string | null;
3052
- weekdayShort: string | null;
3053
- weekdayLong: string | null;
3054
- offset: number;
3055
- offsetNameShort: string | null;
3056
- offsetNameLong: string | null;
3057
- isOffsetFixed: boolean | null;
3058
- isInDST: boolean;
3059
- isInLeapYear: boolean;
3060
- daysInMonth: import("luxon").PossibleDaysInMonth | undefined;
3061
- daysInYear: number;
3062
- weeksInWeekYear: number;
3063
- weeksInLocalWeekYear: number;
3064
- resolvedLocaleOptions: (opts?: import("luxon").LocaleOptions | import("luxon").DateTimeFormatOptions) => import("luxon").ResolvedLocaleOptions;
3065
- toUTC: (offset?: number, opts?: import("luxon").ZoneOptions) => DateTime<boolean>;
3066
- toLocal: () => DateTime<boolean>;
3067
- setZone: (zone?: string | import("luxon").Zone, opts?: import("luxon").ZoneOptions) => import("luxon").DateTimeMaybeValid;
3068
- reconfigure: (properties: import("luxon").LocaleOptions) => DateTime<boolean>;
3069
- setLocale: (locale: string) => DateTime<boolean>;
3070
- set: (values: import("luxon").DateObjectUnits) => DateTime<boolean>;
3071
- plus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
3072
- minus: (duration: import("luxon").DurationLike) => DateTime<boolean>;
3073
- startOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").StartOfOptions) => DateTime<boolean>;
3074
- endOf: (unit: import("luxon").DateTimeUnit, opts?: import("luxon").EndOfOptions) => DateTime<boolean>;
3075
- toFormat: (format: string, options?: import("luxon").LocaleOptions) => string;
3076
- toLocaleString: (formatOpts?: import("luxon").DateTimeFormatOptions, opts?: import("luxon").LocaleOptions) => string;
3077
- toLocaleParts: (opts?: import("luxon").DateTimeFormatOptions) => Intl.DateTimeFormatPart[];
3078
- toISO: (opts?: import("luxon").ToISOTimeOptions) => string | null;
3079
- toISODate: (opts?: import("luxon").ToISODateOptions) => string | null;
3080
- toISOWeekDate: () => string | null;
3081
- toISOTime: (opts?: import("luxon").ToISOTimeOptions) => string | null;
3082
- toRFC2822: () => string | null;
3083
- toHTTP: () => string | null;
3084
- toSQLDate: () => string | null;
3085
- toSQLTime: (opts?: import("luxon").ToSQLOptions) => string | null;
3086
- toSQL: (opts?: import("luxon").ToSQLOptions) => string | null;
3087
- toString: () => string;
3088
- valueOf: () => number;
3089
- toMillis: () => number;
3090
- toSeconds: () => number;
3091
- toUnixInteger: () => number;
3092
- toJSON: () => string | null;
3093
- toBSON: () => Date;
3094
- toObject: <IncludeConfig extends boolean | undefined>(opts?: {
3095
- includeConfig?: IncludeConfig | undefined;
3096
- } | undefined) => import("luxon")._ToObjectOutput<IncludeConfig> | Partial<import("luxon")._ToObjectOutput<IncludeConfig>>;
3097
- toJSDate: () => Date;
3098
- diff: (otherDateTime: DateTime, unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<boolean>;
3099
- diffNow: (unit?: import("luxon").DurationUnits, opts?: import("luxon").DiffOptions) => import("luxon").Duration<import("node_modules/@types/luxon/src/_util").Valid>;
3100
- until: (otherDateTime: DateTime) => import("luxon").Interval<true> | DateTime<false>;
3101
- hasSame: (otherDateTime: DateTime, unit: import("luxon").DateTimeUnit, opts?: import("luxon").HasSameOptions) => boolean;
3102
- equals: (other: DateTime) => boolean;
3103
- toRelative: (options?: import("luxon").ToRelativeOptions) => string | null;
3104
- toRelativeCalendar: (options?: import("luxon").ToRelativeCalendarOptions) => string | null;
3105
- } | null | undefined;
374
+ expiredAt?: string | null | undefined;
3106
375
  } | null;
3107
376
  processing: boolean;
3108
377
  error: string | null;
@@ -3112,11 +381,11 @@ export declare const basketSlice: import("@reduxjs/toolkit").Slice<BasketState,
3112
381
  export declare const setProcessing: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "basket/setProcessing">, initializeOrder: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
3113
382
  id: string;
3114
383
  currency: Currency;
3115
- expiredAt?: DateTime | null;
384
+ expiredAt?: string | null;
3116
385
  }, "basket/initializeOrder">, addProduct: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
3117
386
  input: ProductInput;
3118
387
  amountReserved: number;
3119
- expiredAt?: DateTime | null;
388
+ expiredAt?: string | null;
3120
389
  }, "basket/addProduct">, removeProduct: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
3121
390
  id: string;
3122
391
  amountReleased: number;
@@ -3124,10 +393,10 @@ export declare const setProcessing: import("@reduxjs/toolkit").ActionCreatorWith
3124
393
  }, "basket/removeProduct">, configurePackage: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
3125
394
  input: ConfigurePackageInput;
3126
395
  amountReserved: number;
3127
- expiredAt?: DateTime | null;
396
+ expiredAt?: string | null;
3128
397
  }, "basket/configurePackage">, configureDelivery: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<ConfigureDeliveryInput | undefined, "basket/configureDelivery">, configureCustomer: import("@reduxjs/toolkit").ActionCreatorWithPayload<ConfigureCustomerInput, "basket/configureCustomer">, reserveAdditionalPackageItem: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
3129
398
  input: ReserveAdditionalPackageItemInput;
3130
399
  amountReserved: number;
3131
- expiredAt?: DateTime | null;
400
+ expiredAt?: string | null;
3132
401
  }, "basket/reserveAdditionalPackageItem">, clearBasket: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"basket/clearBasket">;
3133
402
  //# sourceMappingURL=store.d.ts.map