platform-calendar-seatmap 2.0.1 → 2.0.2

package/dist/store/reducers/seatMap/selectors.d.ts

@@ -0,0 +1,474 @@
+import { T_Element, T_ElementType, T_Seat, T_SeatMap } from 'platform-calendar-helpers';
+import { T_RootState } from "../../store";
+declare const selectSeatMap: (state: T_RootState) => T_SeatMap;
+declare const selectSeatMapName: (state: T_RootState) => T_SeatMap["name"];
+/** Sum of standing area limits per ticket ID (capacity "claimed" by standing areas for each ticket). */
+declare const selectStandingAreaCapacityByTicketId: ((state: T_RootState) => {
+    [ticketId: number]: number;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("platform-calendar-helpers").T_Element_StandingArea[]) => {
+        [ticketId: number]: number;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: import("platform-calendar-helpers").T_Element_StandingArea[]) => {
+        [ticketId: number]: number;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        [ticketId: number]: number;
+    };
+    dependencies: [(state: T_RootState) => import("platform-calendar-helpers").T_Element_StandingArea[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const selectSelectedElement: ((state: T_RootState) => T_Element) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, resultFuncArgs_1: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }) => T_Element;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, resultFuncArgs_1: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }) => T_Element) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => T_Element;
+    dependencies: [(state: T_RootState) => {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, (state: T_RootState) => import("../elementSelector/types").T_ElementSelectorState["selected"]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/** Set of seat IDs belonging to the currently selected table or seating group. */
+declare const selectSelectedElementSeatIds: ((state: T_RootState) => Set<string>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: T_Element) => Set<string>;
+    memoizedResultFunc: ((resultFuncArgs_0: T_Element) => Set<string>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Set<string>;
+    dependencies: [((state: T_RootState) => T_Element) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, resultFuncArgs_1: {
+            elementType: T_ElementType;
+            elementId: T_Element["id"];
+            seats: {
+                [key: T_Seat["id"]]: {
+                    id: T_Seat["id"];
+                    elementType: T_ElementType;
+                    elementId: T_Element["id"];
+                    elementTitle: T_Element["title"];
+                } & Partial<T_Seat>;
+            };
+            seatIds: T_Seat["id"][];
+        }) => T_Element;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, resultFuncArgs_1: {
+            elementType: T_ElementType;
+            elementId: T_Element["id"];
+            seats: {
+                [key: T_Seat["id"]]: {
+                    id: T_Seat["id"];
+                    elementType: T_ElementType;
+                    elementId: T_Element["id"];
+                    elementTitle: T_Element["title"];
+                } & Partial<T_Seat>;
+            };
+            seatIds: T_Seat["id"][];
+        }) => T_Element) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => T_Element;
+        dependencies: [(state: T_RootState) => {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, (state: T_RootState) => import("../elementSelector/types").T_ElementSelectorState["selected"]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/** Count of seats assigned to each ticket in the currently selected table or seating group. */
+declare const selectSelectedElementSeatsAssignedByTicket: ((state: T_RootState) => {
+    [ticketId: number]: number;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: T_Element) => {
+        [ticketId: number]: number;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: T_Element) => {
+        [ticketId: number]: number;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        [ticketId: number]: number;
+    };
+    dependencies: [((state: T_RootState) => T_Element) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, resultFuncArgs_1: {
+            elementType: T_ElementType;
+            elementId: T_Element["id"];
+            seats: {
+                [key: T_Seat["id"]]: {
+                    id: T_Seat["id"];
+                    elementType: T_ElementType;
+                    elementId: T_Element["id"];
+                    elementTitle: T_Element["title"];
+                } & Partial<T_Seat>;
+            };
+            seatIds: T_Seat["id"][];
+        }) => T_Element;
+        memoizedResultFunc: ((resultFuncArgs_0: {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, resultFuncArgs_1: {
+            elementType: T_ElementType;
+            elementId: T_Element["id"];
+            seats: {
+                [key: T_Seat["id"]]: {
+                    id: T_Seat["id"];
+                    elementType: T_ElementType;
+                    elementId: T_Element["id"];
+                    elementTitle: T_Element["title"];
+                } & Partial<T_Seat>;
+            };
+            seatIds: T_Seat["id"][];
+        }) => T_Element) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => T_Element;
+        dependencies: [(state: T_RootState) => {
+            seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+            standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+            tables: import("platform-calendar-helpers").T_Element_Table[];
+            objects: import("platform-calendar-helpers").T_Element_Object[];
+            text: import("platform-calendar-helpers").T_Element_Text[];
+            aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+        }, (state: T_RootState) => import("../elementSelector/types").T_ElementSelectorState["selected"]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        memoize: typeof import("reselect").weakMapMemoize;
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const selectSelectorElementToEdit: ((state: T_RootState) => T_Element) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, resultFuncArgs_1: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }, resultFuncArgs_2: import("../elementSelector/types").T_SelectorActiveTab) => T_Element;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, resultFuncArgs_1: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }, resultFuncArgs_2: import("../elementSelector/types").T_SelectorActiveTab) => T_Element) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => T_Element;
+    dependencies: [(state: T_RootState) => {
+        seatingGroup: import("platform-calendar-helpers").T_Element_SeatingGroup[];
+        standingArea: import("platform-calendar-helpers").T_Element_StandingArea[];
+        tables: import("platform-calendar-helpers").T_Element_Table[];
+        objects: import("platform-calendar-helpers").T_Element_Object[];
+        text: import("platform-calendar-helpers").T_Element_Text[];
+        aisles: import("platform-calendar-helpers").T_Element_Aisle[];
+    }, (state: T_RootState) => import("../elementSelector/types").T_ElementSelectorState["selected"], (state: T_RootState) => import("../elementSelector/types").T_SelectorActiveTab];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const selectSelectedSeatsObj: ((state: T_RootState) => {
+    [key: string]: T_Seat;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }) => {
+        [key: string]: T_Seat;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: {
+        elementType: T_ElementType;
+        elementId: T_Element["id"];
+        seats: {
+            [key: T_Seat["id"]]: {
+                id: T_Seat["id"];
+                elementType: T_ElementType;
+                elementId: T_Element["id"];
+                elementTitle: T_Element["title"];
+            } & Partial<T_Seat>;
+        };
+        seatIds: T_Seat["id"][];
+    }) => {
+        [key: string]: T_Seat;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        [key: string]: T_Seat;
+    };
+    dependencies: [(state: T_RootState) => import("platform-calendar-helpers").T_Element_Table[], (state: T_RootState) => import("platform-calendar-helpers").T_Element_SeatingGroup[], (state: T_RootState) => import("../elementSelector/types").T_ElementSelectorState["selected"]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const selectTicketApplieableSeats: ((state: T_RootState, ticketIds: any) => {
+    [k: string]: any;
+}) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: any) => {
+        [k: string]: any;
+    };
+    memoizedResultFunc: ((resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: any) => {
+        [k: string]: any;
+    }) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => {
+        [k: string]: any;
+    };
+    dependencies: [(state: T_RootState) => import("platform-calendar-helpers").T_Element_Table[], (state: T_RootState) => import("platform-calendar-helpers").T_Element_SeatingGroup[], (_: T_RootState, ticketIds: any) => any];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+/** Count of assigned seats for a specific ticket ID across all seating groups and tables. */
+declare const selectAssignedSeatsCountByTicketId: ((state: T_RootState, ticketId: number) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: number) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: import("platform-calendar-helpers").T_Element_Table[], resultFuncArgs_1: import("platform-calendar-helpers").T_Element_SeatingGroup[], resultFuncArgs_2: number) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: T_RootState) => import("platform-calendar-helpers").T_Element_Table[], (state: T_RootState) => import("platform-calendar-helpers").T_Element_SeatingGroup[], (_: T_RootState, ticketId: number) => number];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+declare const selectAllSeatsCount: ((state: T_RootState) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: T_SeatMap) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: T_SeatMap) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [(state: T_RootState) => T_SeatMap];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export { selectSeatMap, selectSelectedSeatsObj, selectSelectedElement, selectSelectedElementSeatIds, selectSelectedElementSeatsAssignedByTicket, selectSelectorElementToEdit, selectSeatMapName, selectTicketApplieableSeats, selectStandingAreaCapacityByTicketId, selectAllSeatsCount, selectAssignedSeatsCountByTicketId };

package/dist/store/reducers/seatMap/types.d.ts

@@ -0,0 +1,70 @@
+import { RecursivePartial } from "../../../helpers/types/commons";
+import { T_Element, T_ElementType, T_Seat, T_SeatMap } from 'platform-calendar-helpers';
+import { T_Element_Aisle } from "../../../helpers/types/aisle";
+import { ADD_ELEMENT, DELETE_ELEMENT, EDIT_ELEMENT, EDIT_SEATS, RESET_DEFAULT_ELEMENT, SET_ELEMENT_POSITION, SET_SEAT_MAP, SET_SEAT_MAP_NAME } from './actionTypes';
+type T_ElementType_SeatMap = T_ElementType | 'aisles';
+type T_Element_SeatMap = T_Element | T_Element_Aisle;
+type T_SeatMapsState = T_SeatMap;
+type T_SetSeatMap = {
+    type: typeof SET_SEAT_MAP;
+    payload: {
+        seatMap: T_SeatMap;
+    };
+};
+type T_SetSeatMapName = {
+    type: typeof SET_SEAT_MAP_NAME;
+    payload: {
+        name: T_SeatMap['name'];
+    };
+};
+type T_AddElement = {
+    type: typeof ADD_ELEMENT;
+    payload: {
+        element: T_Element_SeatMap;
+        type: T_ElementType_SeatMap;
+    };
+};
+type T_DeleteElement = {
+    type: typeof DELETE_ELEMENT;
+    payload: {
+        elementId: T_Element['id'];
+        type: T_ElementType_SeatMap;
+    };
+};
+type T_SetElementPosition = {
+    type: typeof SET_ELEMENT_POSITION;
+    payload: {
+        elementId: T_Element['id'];
+        elementType: T_ElementType_SeatMap;
+        position: {
+            top: number;
+            left: number;
+        };
+    };
+};
+type T_EditSeats = {
+    type: typeof EDIT_SEATS;
+    payload: {
+        elementId: T_Element['id'];
+        elementType: T_ElementType;
+        seats: {
+            [key: string]: Partial<T_Seat>;
+        };
+    };
+};
+type T_EditElement = {
+    type: typeof EDIT_ELEMENT;
+    payload: {
+        elementId: T_Element['id'];
+        elementType: T_ElementType_SeatMap;
+        element: RecursivePartial<T_Element_SeatMap>;
+    };
+};
+type T_ResetDefaultElement = {
+    type: typeof RESET_DEFAULT_ELEMENT;
+    payload: {
+        elementType: T_ElementType_SeatMap;
+    };
+};
+type T_SeatMapsReducerAction = T_SetSeatMap | T_AddElement | T_DeleteElement | T_SetElementPosition | T_EditSeats | T_EditElement | T_SetSeatMapName | T_ResetDefaultElement;
+export type { T_SeatMapsReducerAction, T_SetSeatMap, T_SeatMapsState, T_AddElement, T_DeleteElement, T_SetElementPosition, T_EditSeats, T_EditElement, T_ElementType_SeatMap, T_SetSeatMapName, T_ResetDefaultElement };

package/dist/store/store.d.ts

@@ -0,0 +1,19 @@
+import { legacy_createStore } from 'redux';
+import { T_MainState } from './reducers/main/types';
+import { T_SeatMapsState } from './reducers/seatMap/types';
+import { T_ElementSelectorState } from './reducers/elementSelector/types';
+import { T_ActionHandlersState } from './reducers/actionHandlers/types';
+import { T_HistoryState } from './reducers/history/types';
+import { T_ClipboardState } from './reducers/clipboard/types';
+import { T_SeatMap } from 'platform-calendar-helpers';
+declare const getStore: (seatMapId: T_SeatMap["id"]) => import("redux").Store<unknown, import("redux").Action<string>, unknown>;
+type T_RootState = {
+    seatMap: T_SeatMapsState;
+    main: T_MainState;
+    elementSelector: T_ElementSelectorState;
+    actionHandlers: T_ActionHandlersState;
+    history: T_HistoryState;
+    clipboard: T_ClipboardState;
+};
+type T_Dispatch = ReturnType<typeof legacy_createStore>['dispatch'];
+export { getStore, type T_RootState, type T_Dispatch };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "platform-calendar-seatmap",
-	"version": "2.0.1",
+	"version": "2.0.2",
 	"description": "Powerful and customizable calendar package",
 	"author": {
 		"name": "Arman Azaryan"