@trii/components 2.0.66 → 2.0.68

package/dist/types/components/EventsDialog/hooks/useCalendarEvents.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import { IEvent } from '@trii/types/dist/Calendar';
+export interface CalendarEvent {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    startAt?: Date | string;
+    endAt?: Date | string;
+    allDay?: boolean;
+    color?: string;
+    calendarId?: string;
+    details?: string;
+    location?: string;
+    isPrivate?: boolean;
+    rule?: string;
+    relatedContact?: {
+        id: string;
+        name: string;
+    };
+    sharedWith?: Array<{
+        id: string;
+    }>;
+    finalized?: boolean;
+    kind?: 'event' | 'task';
+    originalOccurrenceDate?: string;
+    parentId?: string;
+}
+export interface UseCalendarEventsType {
+    events: CalendarEvent[];
+    setEvents: React.Dispatch<React.SetStateAction<CalendarEvent[]>>;
+    filteredEvents: CalendarEvent[];
+}
+export declare const useCalendarEventsInitialState: UseCalendarEventsType;
+export declare const useCalendarEvents: (activeCalendarIds: string[], activities: IEvent[]) => UseCalendarEventsType;
+export default useCalendarEvents;

package/dist/types/components/EventsDialog/hooks/useCalendarTasks.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+export interface CalendarTask {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    startAt?: Date | string;
+    endAt?: Date | string;
+    description?: string;
+    calendarId?: string;
+    isCompleted?: boolean;
+    relatedContact?: {
+        id: string;
+        name: string;
+    };
+    kind?: 'task';
+}
+export interface UseCalendarTasksType {
+    tasks: CalendarTask[];
+    setTasks: React.Dispatch<React.SetStateAction<CalendarTask[]>>;
+    filteredTasks: CalendarTask[];
+}
+export declare const useCalendarTasksInitialState: UseCalendarTasksType;
+export declare const useCalendarTasks: (activeCalendarIds: string[]) => UseCalendarTasksType;
+export default useCalendarTasks;

package/dist/types/components/EventsDialog/hooks/useDialog.d.ts

@@ -0,0 +1,8 @@
+export interface UseDialog {
+    open: boolean;
+    handleOpen: () => void;
+    handleClose: () => void;
+}
+export declare const useDialogInitialState: UseDialog;
+export declare const useDialog: () => UseDialog;
+export default useDialog;

package/dist/types/components/EventsDialog/hooks/useEvent.d.ts

@@ -0,0 +1,71 @@
+import { Dayjs } from 'dayjs';
+import { UseFieldType } from './useField';
+import { IContact } from '@trii/types/dist/Contacts';
+import { UseNotificationsType } from './useNotifications';
+export interface UseDateState {
+    state: {
+        selectedStartDate: Dayjs;
+        selectedEndDate: Dayjs;
+        error: boolean;
+    };
+    action: {
+        setSelectedStartDate: (date: Dayjs) => void;
+        setSelectedEndDate: (date: Dayjs) => void;
+        setError: (error: boolean) => void;
+        handleSelect: (setter: (date: Dayjs) => void) => (date: Dayjs) => void;
+    };
+}
+export interface UseLinkContact {
+    state: {
+        search: string;
+        contactSelectedId: string;
+    };
+    action: {
+        handleSelectContact: (contact: IContact) => void;
+        handleSearchChange: (search: string) => void;
+        resetField: () => void;
+    };
+}
+export interface UseShareWithUsers {
+    field: {
+        userIds: string[];
+    };
+    action: {
+        setUserIds: (ids: string[]) => void;
+        resetField: () => void;
+    };
+}
+export interface UseEvent {
+    titleField: UseFieldType;
+    descriptionField: UseFieldType;
+    locationField: UseFieldType;
+    colorField: UseFieldType;
+    date: UseDateState;
+    allDay: boolean;
+    setAllDay: (value: boolean) => void;
+    isPrivate: boolean;
+    setIsPrivate: (value: boolean) => void;
+    recurrenceRule: string;
+    setRecurrenceRule: (rule: string) => void;
+    notifications: UseNotificationsType;
+    shareWithUsers: UseShareWithUsers;
+    linkContact: UseLinkContact;
+    create: () => {
+        title: string;
+        details: string;
+        location: string;
+        allDay: boolean;
+        isPrivate: boolean;
+        color: string;
+        startAt: string;
+        endAt: string;
+        notifications: any[];
+        sharedWith: string[];
+        rule: string;
+        relatedContactId?: string;
+    };
+    resetFields: () => void;
+}
+export declare const useEventInitialState: UseEvent;
+declare const useEvent: (selectedEvent?: any) => UseEvent;
+export default useEvent;

package/dist/types/components/EventsDialog/hooks/useField.d.ts

@@ -0,0 +1,19 @@
+import { ChangeEvent } from 'react';
+export interface UseFieldType {
+    actions: {
+        onError: (errorMsg: string) => void;
+        onSuccess: () => void;
+        resetValue: () => void;
+        changeValue: (newValue: string) => void;
+    };
+    attributes: {
+        error: boolean;
+        helperText: string;
+        type: string;
+        value: string;
+        onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    };
+}
+export declare const useFieldInitialState: UseFieldType;
+declare const useField: (type: string, initialValue?: string) => UseFieldType;
+export default useField;

package/dist/types/components/EventsDialog/hooks/useNotifications.d.ts

@@ -0,0 +1,27 @@
+import { ChangeEvent } from 'react';
+import { IEventNotification } from '@trii/types/dist/Calendar';
+import { SelectChangeEvent } from '@mui/material';
+import { EventNotificationFront } from '../types';
+export declare const useNotificationsInitialDef: {
+    notifications: never[];
+    action: {
+        addNotification: () => void;
+        deleteNotification: (_notificationId: string) => void;
+        handleTimeFieldChange: (_event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>, _notificationId: string) => void;
+        handleTimePeriodChange: (_event: SelectChangeEvent<unknown>, _notificationId: string) => void;
+        handleReminderChange: (_event: ChangeEvent<HTMLInputElement>, _notificationId: string) => void;
+        resetNotifications: () => void;
+    };
+};
+export type UseNotificationsType = {
+    notifications: EventNotificationFront[];
+    action: {
+        addNotification: () => void;
+        deleteNotification: (notificationId: string) => void;
+        handleTimeFieldChange: (event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>, notificationId: string) => void;
+        handleTimePeriodChange: (event: SelectChangeEvent<unknown>, notificationId: string) => void;
+        handleReminderChange: (event: ChangeEvent<HTMLInputElement>, notificationId: string) => void;
+        resetNotifications: () => void;
+    };
+};
+export declare function useNotifications(eventNotifications?: IEventNotification[]): UseNotificationsType;

package/dist/types/components/EventsDialog/hooks/useSelect.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { SelectChangeEvent } from '@mui/material';
+export interface UseSelect {
+    actions: {
+        resetValue: () => void;
+        changeValue: (newValue: string | number) => void;
+    };
+    attributes: {
+        value: string | number;
+        onChange: (event: SelectChangeEvent<string>, child: ReactNode) => void;
+    };
+}
+declare const useSelect: (initialValue: string | number) => UseSelect;
+export default useSelect;

package/dist/types/components/EventsDialog/hooks/useTask.d.ts

@@ -0,0 +1,19 @@
+import { UseFieldType } from './useField';
+import { UseDateState, UseLinkContact } from './useEvent';
+export interface UseTask {
+    titleField: UseFieldType;
+    descriptionField: UseFieldType;
+    date: UseDateState;
+    linkContact: UseLinkContact;
+    create: () => {
+        title: string;
+        description: string;
+        startAt: string;
+        endAt: string;
+        relatedContactId?: string;
+    };
+    resetFields: () => void;
+}
+export declare const useTaskInitialState: UseTask;
+declare const useTask: (selectedTask?: any) => UseTask;
+export default useTask;

package/dist/types/components/EventsDialog/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * EventsDialog - Componente para gestión de eventos y tareas
+ *
+ * Uso:
+ * ```tsx
+ * import { EventsDialog } from '@trii/components';
+ *
+ * <EventsDialog
+ *   open={isOpen}
+ *   onClose={handleClose}
+ *   baseUrl="https://api.trii.app/api/v1"
+ *   spaceId={spaceId}
+ *   language="es"
+ *   mode="create"
+ *   type="event"
+ *   calendars={myCalendars}
+ *   onCreateEvent={(data) => createEvent(data)}
+ *   onUpdateEvent={(id, data) => updateEvent(id, data)}
+ *   onDeleteEvent={(id) => deleteEvent(id)}
+ * />
+ * ```
+ */
+export { default } from './EventsDialog';
+export { default as EventsDialog } from './EventsDialog';
+export type { EventsDialogProps, EventData, TaskData } from './EventsDialog';
+export * from './types';

package/dist/types/components/EventsDialog/layout/BasicInputContainer/BasicInputContainer.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+type BasicInputContainerProps = {
+    name: string;
+    children: ReactNode;
+};
+declare const BasicInputContainer: ({ name, children }: BasicInputContainerProps) => import("react/jsx-runtime").JSX.Element;
+export default BasicInputContainer;

package/dist/types/components/EventsDialog/layout/BasicInputContainer/index.d.ts

@@ -0,0 +1 @@
+export { default } from './BasicInputContainer';

package/dist/types/components/EventsDialog/layout/BasicInputContainer/styles.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const StyledBoxContainer: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
+export declare const StyledDialogContextText: import("@emotion/styled").StyledComponent<import("@mui/system").BoxOwnProps<import("@mui/material").Theme> & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof import("@mui/system").BoxOwnProps<import("@mui/material").Theme>> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;

package/dist/types/components/EventsDialog/layout/InputContainer/InputContainer.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+type InputContainerProps = {
+    children: ReactNode;
+    title: string;
+};
+declare const InputContainer: ({ children, title }: InputContainerProps) => import("react/jsx-runtime").JSX.Element;
+export default InputContainer;

package/dist/types/components/EventsDialog/layout/InputContainer/index.d.ts

@@ -0,0 +1 @@
+export { default } from './InputContainer';

package/dist/types/components/EventsDialog/layout/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BasicInputContainer } from './BasicInputContainer';
+export { default as InputContainer } from './InputContainer';

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/activitiesSlice.d.ts

@@ -0,0 +1,27 @@
+import { IEvent } from '@trii/types/dist/Calendar';
+import type { ActivitiesSlice } from './types/ActivitiesSlice';
+import type { AddActivityRequestData } from './types/AddActivityRequestData';
+import type { UpdatedActivityRequestData } from './types/UpdateActivityRequestData';
+export declare const fetchActivities: import("@reduxjs/toolkit").AsyncThunk<IEvent[], void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const addActivity: import("@reduxjs/toolkit").AsyncThunk<IEvent, AddActivityRequestData, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const deleteActivity: import("@reduxjs/toolkit").AsyncThunk<{
+    activityId: string;
+    originalOccurrenceDate?: string | Date | undefined;
+}, {
+    activityId: string;
+    originalOccurrenceDate?: string | Date | undefined;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const endActivity: import("@reduxjs/toolkit").AsyncThunk<IEvent, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const updateActivity: import("@reduxjs/toolkit").AsyncThunk<IEvent, UpdatedActivityRequestData, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const fetchActivityById: import("@reduxjs/toolkit").AsyncThunk<IEvent, {
+    spaceId: string;
+    eventId: string;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const updateActivityBySpaceThunk: import("@reduxjs/toolkit").AsyncThunk<IEvent, {
+    baseUrl: string;
+    spaceId: string;
+    eventId: string;
+    updatedActivity: object;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+declare const _default: import("redux").Reducer<ActivitiesSlice>;
+export default _default;

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/types/ActivitiesSlice.d.ts

@@ -0,0 +1,12 @@
+import { IEvent } from '@trii/types/dist/Calendar';
+import { RequestStatus } from 'redux/types/RequestStatus';
+export type ActivitiesSlice = {
+    activities: IEvent[];
+    status: {
+        fetch: RequestStatus;
+        add: RequestStatus;
+        delete: RequestStatus;
+        updateEnding: RequestStatus;
+        update: RequestStatus;
+    };
+};

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/types/ActivitiesTableColumnName.d.ts

@@ -0,0 +1 @@
+export type ActivitiesTableColumnName = 'title' | 'date' | 'duration' | 'startAt' | 'createdBy' | 'sharedWith';

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/types/AddActivityRequestData.d.ts

@@ -0,0 +1,19 @@
+import { EventNotificationFront } from './EventNotificationFront';
+export type AddActivityRequestData = {
+    isPrivate: boolean;
+    startAt: Date;
+    endAt: Date;
+    allDay: boolean;
+    notifications: EventNotificationFront[];
+    contactId: string;
+    title: string;
+    details: string;
+    location: string;
+    color?: string;
+    eventTypeId: string;
+    calendarId: string;
+    repeatId: string;
+    sharedWith: string[];
+    rule?: string;
+    originalOccurrenceDate?: Date | string;
+};

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/types/EventNotificationFront.d.ts

@@ -0,0 +1,2 @@
+import { IEventNotification } from '@trii/types/dist/Calendar';
+export type EventNotificationFront = Omit<IEventNotification, 'notificacionDateTime'>;

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/types/UpdateActivityRequestData.d.ts

@@ -0,0 +1,6 @@
+import { IEvent } from '@trii/types/dist/Calendar';
+export type UpdatedActivityRequestData = {
+    updatedActivity: Partial<IEvent>;
+    activityId: string;
+    originalOccurrenceDate?: Date | string;
+};

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/utils/activitiesSliceService.d.ts

@@ -0,0 +1,12 @@
+import { IEvent } from '@trii/types/dist/Calendar';
+import { AddActivityRequestData } from '../types/AddActivityRequestData';
+declare const updateActivityBySpace: (baseUrl: string, spaceId: string, eventId: string, updateActivityRequestData: object) => Promise<IEvent>;
+declare const getActivityById: (spaceId: string, eventId: string) => Promise<IEvent>;
+declare const _default: {
+    fetchActivities: (URL: string) => Promise<IEvent[]>;
+    addActivity: (URL: string, addActivityRequestData: AddActivityRequestData) => Promise<IEvent>;
+    deleteActivity: (baseURL: string, eventId: string, originalOccurrenceDate?: string | Date | undefined) => Promise<void>;
+    updateActivity: (baseURL: string, eventId: string, updateActivityRequestData: any, originalOccurrenceDate?: string | Date | undefined) => Promise<IEvent>;
+};
+export default _default;
+export { updateActivityBySpace, getActivityById };

package/dist/types/components/EventsDialog/redux/features/activitiesSlice/utils/selectors.d.ts

@@ -0,0 +1,132 @@
+import type { ActivitiesSlice } from '../types/ActivitiesSlice';
+type LocalState = {
+    Activities: ActivitiesSlice;
+};
+export declare const selectActivitiesSlice: (state: LocalState) => ActivitiesSlice;
+export declare const selectActivities: ((state: LocalState) => import("@trii/types/dist/Calendar").IEvent[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("@trii/types/dist/Calendar").IEvent[]) => import("@trii/types/dist/Calendar").IEvent[];
+    memoizedResultFunc: ((resultFuncArgs_0: import("@trii/types/dist/Calendar").IEvent[]) => import("@trii/types/dist/Calendar").IEvent[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("@trii/types/dist/Calendar").IEvent[];
+    dependencies: [(state: LocalState) => import("@trii/types/dist/Calendar").IEvent[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectActivitiesFetchStatus: ((state: LocalState) => import("../../../types/RequestStatus").RequestStatus) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../types/RequestStatus").RequestStatus;
+    dependencies: [(state: LocalState) => import("../../../types/RequestStatus").RequestStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectActivitiesAddStatus: ((state: LocalState) => import("../../../types/RequestStatus").RequestStatus) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../types/RequestStatus").RequestStatus;
+    dependencies: [(state: LocalState) => import("../../../types/RequestStatus").RequestStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectActivitiesDeleteStatus: ((state: LocalState) => import("../../../types/RequestStatus").RequestStatus) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../types/RequestStatus").RequestStatus;
+    dependencies: [(state: LocalState) => import("../../../types/RequestStatus").RequestStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectActivitiesUpdateEndingStatus: ((state: LocalState) => import("../../../types/RequestStatus").RequestStatus) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../types/RequestStatus").RequestStatus;
+    dependencies: [(state: LocalState) => import("../../../types/RequestStatus").RequestStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectActivitiesUpdateStatus: ((state: LocalState) => import("../../../types/RequestStatus").RequestStatus) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../../types/RequestStatus").RequestStatus) => import("../../../types/RequestStatus").RequestStatus) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../../types/RequestStatus").RequestStatus;
+    dependencies: [(state: LocalState) => import("../../../types/RequestStatus").RequestStatus];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export {};

package/dist/types/components/EventsDialog/redux/features/calendarsSlice/calendarsSlice.d.ts

@@ -0,0 +1,12 @@
+import { ICalendar } from '@trii/types/dist/Calendar/Calendar';
+import type { CalendarsSlice } from './types/CalendarSlice';
+import { AddCalendarRequestData } from './types/AddCalendarResquestData';
+export declare const fetchCalendars: import("@reduxjs/toolkit").AsyncThunk<ICalendar[], void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const addCalendar: import("@reduxjs/toolkit").AsyncThunk<ICalendar, AddCalendarRequestData, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const deleteCalendar: import("@reduxjs/toolkit").AsyncThunk<string, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const updateCalendar: import("@reduxjs/toolkit").AsyncThunk<ICalendar, {
+    calendarId: string;
+    payload: AddCalendarRequestData;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+declare const _default: import("redux").Reducer<CalendarsSlice>;
+export default _default;

package/dist/types/components/EventsDialog/redux/features/calendarsSlice/types/AddCalendarResquestData.d.ts

@@ -0,0 +1,5 @@
+export type AddCalendarRequestData = {
+    title: string;
+    color: string;
+    sharedWith?: string[];
+};

package/dist/types/components/EventsDialog/redux/features/calendarsSlice/types/CalendarSlice.d.ts

@@ -0,0 +1,10 @@
+import { ICalendar } from '@trii/types/dist/Calendar/Calendar';
+export type CalendarsSlice = {
+    calendars: ICalendar[];
+    status: {
+        fetch: 'idle' | 'loading' | 'succeeded';
+        add: 'idle' | 'loading';
+        delete: 'idle' | 'loading';
+        update: 'idle' | 'loading';
+    };
+};

package/dist/types/components/EventsDialog/redux/features/calendarsSlice/utils/calendarsSliceService.d.ts

@@ -0,0 +1,9 @@
+import { ICalendar } from '@trii/types/dist/Calendar/Calendar';
+import { AddCalendarRequestData } from '../types/AddCalendarResquestData';
+declare const _default: {
+    fetchCalendars: (URL: string) => Promise<ICalendar[]>;
+    addCalendar: (URL: string, addCalendarRequestData: AddCalendarRequestData) => Promise<ICalendar>;
+    deleteCalendar: (URL: string) => Promise<void>;
+    updateCalendar: (URL: string, updateCalendarRequestData: AddCalendarRequestData) => Promise<ICalendar>;
+};
+export default _default;