@trii/components 2.0.65 → 2.0.68

package/dist/types/components/EventsDialog/redux/types/BasicRequests.d.ts

@@ -0,0 +1,11 @@
+import { RequestStatus } from './RequestStatus';
+export interface BasicRequests {
+    fetch: RequestStatus;
+    create: RequestStatus;
+    delete: RequestStatus;
+    update: RequestStatus;
+}
+export interface BasicRequestsWithNoUpdate extends Omit<BasicRequests, 'update'> {
+}
+export interface FetchUpdateRequests extends Omit<Omit<BasicRequests, 'create'>, 'delete'> {
+}

package/dist/types/components/EventsDialog/redux/types/ChangePermissionReadMessagesAction.d.ts

@@ -0,0 +1,4 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { PermissionReadMessagesPayload } from './PermissionReadMessagesPayload';
+export interface ChangePermissionReadMessagesAction extends PayloadAction<PermissionReadMessagesPayload> {
+}

package/dist/types/components/EventsDialog/redux/types/ChangePermissionStartConversationsAction.d.ts

@@ -0,0 +1,4 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { PermissionStartConversationsPayload } from './PermissionStartConversationsPayload';
+export interface ChangePermissionStartConversationsAction extends PayloadAction<PermissionStartConversationsPayload> {
+}

package/dist/types/components/EventsDialog/redux/types/ChangeScheduleFn.d.ts

@@ -0,0 +1,3 @@
+import { ISchedule } from "@trii/types/dist/Common/Schedules";
+import { PayloadAction } from '@reduxjs/toolkit';
+export type ChangeScheduleFn = (payload: ISchedule) => PayloadAction<ISchedule>;

package/dist/types/components/EventsDialog/redux/types/Gif.d.ts

@@ -0,0 +1,41 @@
+type GifData = {
+    url: string;
+    duration: number;
+    preview: string;
+    dims: [];
+    size: number;
+};
+type MediaFormat = {
+    mediumgif: GifData;
+    webm: GifData;
+    tinygifpreview: GifData;
+    tinymp4: GifData;
+    nanomp4: GifData;
+    nanowebm: GifData;
+    loopedmp4: GifData;
+    tinywebm: GifData;
+    mp4: GifData;
+    gif: GifData;
+    tinygif: GifData;
+    gifpreview: GifData;
+    nanogifpreview: GifData;
+    nanogif: GifData;
+};
+export interface Result {
+    id: string;
+    title: string;
+    media_formats: MediaFormat;
+    created: number;
+    content_description: string;
+    itemurl: string;
+    url: string;
+    tags: [];
+    flags: [];
+    hasaudio: boolean;
+}
+export interface Gif {
+    locale: string;
+    results: Result[];
+    next: string;
+}
+export {};

package/dist/types/components/EventsDialog/redux/types/InitRequestDataReturn.d.ts

@@ -0,0 +1,10 @@
+interface InitRequestDataReturn {
+    URL_USER: string;
+    URL_USERS: string;
+    URL_CONVERSATIONS: string;
+    URL_CONTACTS: string;
+    URL_MEDIA: string;
+    URL_MESSAGES: string;
+    URL_CALENDAR: string;
+}
+export default InitRequestDataReturn;

package/dist/types/components/EventsDialog/redux/types/PermissionReadMessagesPayload.d.ts

@@ -0,0 +1,4 @@
+export interface PermissionReadMessagesPayload {
+    permissionGroupId: string;
+    readMessages: boolean;
+}

package/dist/types/components/EventsDialog/redux/types/PermissionStartConversationsPayload.d.ts

@@ -0,0 +1,4 @@
+export interface PermissionStartConversationsPayload {
+    permissionGroupId: string;
+    startConversations: boolean;
+}

package/dist/types/components/EventsDialog/redux/types/RemovePermissionAction.d.ts

@@ -0,0 +1,3 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+export interface RemovePermissionAction extends PayloadAction<string> {
+}

package/dist/types/components/EventsDialog/redux/types/RequestStatus.d.ts

@@ -0,0 +1 @@
+export type RequestStatus = 'idle' | 'loading' | 'succeeded' | 'rejected';

package/dist/types/components/EventsDialog/redux/types/SearchBy.d.ts

@@ -0,0 +1,4 @@
+export interface SearchBy {
+    id: string;
+    name: string;
+}

package/dist/types/components/EventsDialog/redux/types/SortOrder.d.ts

@@ -0,0 +1 @@
+export type SortOrder = 'ASC' | 'DESC';

package/dist/types/components/EventsDialog/redux/types/UpdateChannelThunk.d.ts

@@ -0,0 +1,6 @@
+import { AsyncThunk } from '@reduxjs/toolkit';
+import { RootState } from 'redux/store';
+import { IChannel } from '@trii/types/dist/Common/Channels';
+export type UpdateChannelThunk = AsyncThunk<IChannel, void, {
+    state: RootState;
+}>;

package/dist/types/components/EventsDialog/services/api.d.ts

@@ -0,0 +1,196 @@
+import { IBusiness, IContact, IContactField, IContactTag, IContactAddress } from '@trii/types/dist/Contacts/contacts';
+import { ILabel } from '@trii/types/dist/Contacts';
+import { ChannelType } from '@trii/types/dist/Common/Channels';
+import { UserTrii } from '@trii/types/dist/Users';
+import type { UserInfo } from '@trii/types/dist/Users';
+type ApiContext = {
+    baseUrl: string;
+    spaceId: string;
+};
+type WithSignal = {
+    signal?: AbortSignal;
+};
+type ApiArgs = ApiContext & WithSignal;
+export type Order = 'ASC' | 'DESC';
+export type Filter = {
+    column: string;
+    condition: string;
+    value: string;
+};
+export type TableItemFormat = 'IContact' | 'IBusiness' | 'IContactInfo';
+export type PaginationFolder = 'Main' | 'Trash' | 'MyContacts';
+export type Pagination = {
+    total: number;
+    lastPage: number;
+    currentPage: number;
+    perPage: number;
+    order: Order;
+    orderColumn: string;
+    filter: Filter[];
+    format: TableItemFormat;
+    folder?: PaginationFolder;
+};
+export type PaginationInfo = {
+    total: number;
+    lastPage: number;
+    currentPage: number;
+    perPage: number;
+    cantPageElements: number;
+};
+export type BusinessTableData = {
+    contactos: IBusiness[];
+    contactosIds: unknown[];
+    paginacion: PaginationInfo;
+};
+type FetchContactArgs = ApiArgs & {
+    contactId: string;
+};
+type FetchBusinessArgs = ApiArgs & {
+    businessId: string;
+};
+type FetchLabelsArgs = ApiArgs;
+type CreateLabelArgs = ApiArgs & {
+    name: string;
+};
+export declare function fetchLabels({ baseUrl, spaceId, signal }: FetchLabelsArgs): Promise<ILabel[]>;
+export declare function createLabel({ baseUrl, spaceId, name, signal }: CreateLabelArgs): Promise<ILabel>;
+export declare function fetchContact({ baseUrl, spaceId, contactId, signal }: FetchContactArgs): Promise<IContact | IBusiness>;
+export declare function fetchBusiness({ baseUrl, spaceId, businessId, signal }: FetchBusinessArgs): Promise<IContact | IBusiness>;
+type FetchContactFieldsArgs = ApiArgs & {
+    forType: 'contact' | 'business';
+};
+export declare function fetchContactFields({ baseUrl, spaceId, forType, signal, }: FetchContactFieldsArgs): Promise<IContactField[]>;
+type UpdateEntityArgs = ApiArgs & {
+    entityType: 'contact' | 'business';
+    entityId: string;
+    body: Partial<IContact> | Partial<IBusiness> | {
+        tags: IContactTag[];
+    };
+};
+export declare function updateEntity({ baseUrl, spaceId, entityType, entityId, body, signal, }: UpdateEntityArgs): Promise<IContact | IBusiness>;
+type FetchBusinessTableDataArgs = ApiArgs & {
+    pagination: Pagination;
+};
+export declare function fetchBusinessTableData({ baseUrl, spaceId, pagination, signal, }: FetchBusinessTableDataArgs): Promise<BusinessTableData>;
+type CreateBusinessArgs = ApiArgs & {
+    business: Record<string, unknown>;
+};
+export declare function createBusiness({ baseUrl, spaceId, business, signal }: CreateBusinessArgs): Promise<IBusiness>;
+type DeleteContactAddressData = {
+    contactId: string;
+    contactAddressId: string;
+    type: ChannelType;
+};
+type CheckContactAddressData = {
+    address: string;
+    type: ChannelType;
+};
+type ResultContactAddressCheck = {
+    success: boolean;
+    warnings: string[];
+};
+type DeleteContactAddressArgs = ApiArgs & {
+    data: DeleteContactAddressData;
+};
+type CheckContactAddressArgs = ApiArgs & {
+    data: CheckContactAddressData;
+};
+export type SetContactAddressRequestData = {
+    address: string;
+    type: ChannelType;
+    contactId: string;
+};
+export type UpdateContactAddressData = {
+    contactId: string;
+    contactAddressId: string;
+    note?: string;
+    isFavorite?: boolean;
+};
+type SetContactAddressArgs = ApiArgs & {
+    data: SetContactAddressRequestData;
+};
+type UpdateContactAddressArgs = ApiArgs & {
+    data: UpdateContactAddressData;
+};
+export declare function deleteAddress({ baseUrl, spaceId, data, signal }: DeleteContactAddressArgs): Promise<unknown>;
+export declare function checkContactAddress({ baseUrl, spaceId, data, signal, }: CheckContactAddressArgs): Promise<ResultContactAddressCheck>;
+export declare function setContactAddress({ baseUrl, spaceId, data, signal }: SetContactAddressArgs): Promise<IContactAddress>;
+export declare function updateContactAddress({ baseUrl, spaceId, data, signal, }: UpdateContactAddressArgs): Promise<IContactAddress>;
+type FetchUserTriiArgs = ApiArgs;
+export declare function fetchUserTrii({ baseUrl, spaceId, signal }: FetchUserTriiArgs): Promise<UserTrii>;
+type FetchUsersArgs = ApiArgs;
+export declare function fetchUsers({ baseUrl, spaceId, signal }: FetchUsersArgs): Promise<UserInfo[]>;
+type FetchUserTriiByIdArgs = ApiArgs & {
+    userId: string;
+};
+export declare function fetchUserTriiById({ baseUrl, spaceId, signal, userId, }: FetchUserTriiByIdArgs): Promise<UserTrii>;
+type UploadAvatarArgs = ApiArgs & {
+    contactId: string;
+    file: File;
+};
+export declare function uploadAvatar({ baseUrl, spaceId, contactId, file, signal, }: UploadAvatarArgs): Promise<string>;
+type FetchContactBoundArgs = WithSignal & {
+    contactId: string;
+};
+type FetchBusinessBoundArgs = WithSignal & {
+    businessId: string;
+};
+type FetchContactFieldsBoundArgs = WithSignal & {
+    forType: 'contact' | 'business';
+};
+type CreateLabelBoundArgs = WithSignal & {
+    name: string;
+};
+type UpdateEntityBoundArgs = WithSignal & {
+    entityType: 'contact' | 'business';
+    entityId: string;
+    body: Partial<IContact> | Partial<IBusiness> | {
+        tags: IContactTag[];
+    };
+};
+type FetchBusinessTableDataBoundArgs = WithSignal & {
+    pagination: Pagination;
+};
+type CreateBusinessBoundArgs = WithSignal & {
+    business: Record<string, unknown>;
+};
+type DeleteContactAddressBoundArgs = WithSignal & {
+    data: DeleteContactAddressData;
+};
+type CheckContactAddressBoundArgs = WithSignal & {
+    data: CheckContactAddressData;
+};
+type FetchUserTriiByIdBoundArgs = WithSignal & {
+    userId: string;
+};
+type UploadAvatarBoundArgs = WithSignal & {
+    contactId: string;
+    file: File;
+};
+type SetContactAddressBoundArgs = WithSignal & {
+    data: SetContactAddressRequestData;
+};
+type UpdateContactAddressBoundArgs = WithSignal & {
+    data: UpdateContactAddressData;
+};
+export declare const createEditContactApi: (baseUrl: string, spaceId: string) => {
+    fetchLabels: ({ signal }?: WithSignal) => Promise<ILabel[]>;
+    createLabel: ({ name, signal }: CreateLabelBoundArgs) => Promise<ILabel>;
+    fetchContact: ({ contactId, signal }: FetchContactBoundArgs) => Promise<IContact | IBusiness>;
+    fetchBusiness: ({ businessId, signal }: FetchBusinessBoundArgs) => Promise<IContact | IBusiness>;
+    fetchBusinessTableData: ({ pagination, signal }: FetchBusinessTableDataBoundArgs) => Promise<BusinessTableData>;
+    createBusiness: ({ business, signal }: CreateBusinessBoundArgs) => Promise<IBusiness>;
+    fetchContactFields: ({ forType, signal }: FetchContactFieldsBoundArgs) => Promise<IContactField[]>;
+    updateEntity: ({ entityType, entityId, body, signal }: UpdateEntityBoundArgs) => Promise<IContact | IBusiness>;
+    deleteAddress: ({ data, signal }: DeleteContactAddressBoundArgs) => Promise<unknown>;
+    deleteAddres: ({ data, signal }: DeleteContactAddressBoundArgs) => Promise<unknown>;
+    checkContactAddress: ({ data, signal }: CheckContactAddressBoundArgs) => Promise<ResultContactAddressCheck>;
+    setContactAddress: ({ data, signal }: SetContactAddressBoundArgs) => Promise<IContactAddress>;
+    updateContactAddress: ({ data, signal }: UpdateContactAddressBoundArgs) => Promise<IContactAddress>;
+    fetchUserTrii: ({ signal }?: WithSignal) => Promise<UserTrii>;
+    fetchUsers: ({ signal }?: WithSignal) => Promise<UserInfo[]>;
+    fetchUserTriiById: ({ userId, signal }: FetchUserTriiByIdBoundArgs) => Promise<UserTrii>;
+    uploadAvatar: ({ contactId, file, signal }: UploadAvatarBoundArgs) => Promise<string>;
+};
+export type EditContactApi = ReturnType<typeof createEditContactApi>;
+export {};

package/dist/types/components/EventsDialog/services/http.d.ts

@@ -0,0 +1,23 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export declare class ApiError extends Error {
+    status: number;
+    body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+type RequestJsonArgs = {
+    url: string;
+    method?: HttpMethod;
+    headers?: HeadersInit;
+    body?: unknown;
+    signal?: AbortSignal;
+};
+export declare function requestJson<T>({ url, method, headers, body, signal, }: RequestJsonArgs): Promise<T>;
+type RequestFormDataArgs = {
+    url: string;
+    method?: HttpMethod;
+    headers?: HeadersInit;
+    formData: FormData;
+    signal?: AbortSignal;
+};
+export declare function requestFormData<T>({ url, method, headers, formData, signal, }: RequestFormDataArgs): Promise<T>;
+export {};

package/dist/types/components/EventsDialog/services/urls.d.ts

@@ -0,0 +1,6 @@
+export declare function joinUrl(baseUrl: string, path: string): string;
+export declare function getApiUrls(baseUrl: string, spaceId: string): {
+    CONTACTS: string;
+    MEDIA: string;
+    SETTINGS: string;
+};

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

@@ -0,0 +1,129 @@
+/**
+ * Modos de operación del modal
+ */
+export type ModalMode = 'create' | 'edit' | 'view';
+/**
+ * Tipos de elementos que puede manejar el modal
+ */
+export type ItemType = 'event' | 'task';
+/**
+ * Estructura de una notificación/recordatorio
+ */
+export interface Notification {
+    id?: string;
+    type: 'minutes' | 'hours' | 'days';
+    value: number;
+    sendToContact?: boolean;
+}
+/**
+ * Estructura de un calendario
+ */
+export interface Calendar {
+    id: string;
+    name?: string;
+    title?: string;
+    color?: string;
+}
+/**
+ * Estructura de un contacto
+ */
+export interface Contact {
+    id: string;
+    name: string;
+    email?: string;
+    phone?: string;
+    avatarUrl?: string;
+}
+/**
+ * Datos de un evento
+ */
+export interface EventData {
+    id?: string;
+    title: string;
+    details?: string;
+    description?: string;
+    startAt: string;
+    endAt: string;
+    allDay: boolean;
+    calendarId?: string;
+    color?: string;
+    location?: string;
+    isPrivate?: boolean;
+    rule?: string;
+    notifications?: Notification[];
+    relatedContactId?: string;
+    sharedWith?: string[];
+}
+/**
+ * Datos de una tarea
+ */
+export interface TaskData {
+    id?: string;
+    title: string;
+    description?: string;
+    startAt: string;
+    endAt: string;
+    calendarId?: string;
+    isCompleted?: boolean;
+    relatedContactId?: string;
+}
+/**
+ * Re-exportar tipos del contexto
+ */
+export type { Mode } from './context/types/Mode';
+export type { DialogType } from './context/types/DialogType';
+export type { CalendarDialogMode } from './context/types/CalendarDialogMode';
+import { IEvent, IEventNotification } from '@trii/types/dist/Calendar';
+/** Front-end notification shape (sin notificacionDateTime del backend) */
+export type EventNotificationFront = Omit<IEventNotification, 'notificacionDateTime'>;
+/** Payload para crear un evento */
+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;
+};
+/** Payload para actualizar un evento */
+export type UpdatedActivityRequestData = {
+    updatedActivity: Partial<IEvent>;
+    activityId: string;
+    originalOccurrenceDate?: Date | string;
+};
+/** Payload para crear una tarea */
+export type AddTaskRequestData = {
+    title: string;
+    calendarId: string;
+    startAt: string;
+    description?: string;
+    contactId?: string | null;
+};
+/** Payload para actualizar una tarea */
+export type UpdateTaskRequestData = {
+    taskId: string;
+    updatedTask: {
+        title: string;
+        description?: string;
+        startAt?: Date | string;
+        calendarId?: string;
+        contactId?: string | null;
+    };
+};
+/** Payload para crear/editar un calendario */
+export type AddCalendarRequestData = {
+    title: string;
+    color: string;
+    sharedWith?: string[];
+    googleCalendar?: any;
+};

package/dist/types/components/EventsDialog/utils/eventIdUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Utilidades para manejar IDs de eventos, especialmente eventos recurrentes
+ */
+/**
+ * Extrae el ID base de un evento, eliminando el sufijo de fecha si existe.
+ * Los eventos recurrentes pueden tener IDs con formato: {baseId}_{timestamp}
+ * Ejemplo: "69a722567f4f3905181c5bfa_20260314180200" -> "69a722567f4f3905181c5bfa"
+ *
+ * @param eventId - El ID del evento que puede contener un sufijo de timestamp
+ * @returns El ID base sin el sufijo de timestamp
+ */
+export declare const extractBaseEventId: (eventId: string) => string;
+/**
+ * Obtiene el ID correcto para usar en operaciones API de eventos.
+ * Para eventos recurrentes, usa el parentId si existe.
+ * Para eventos normales o cuando no hay parentId, extrae el ID base.
+ *
+ * @param event - El evento con posible parentId y originalOccurrenceDate
+ * @returns El ID apropiado para usar en llamadas API
+ */
+export declare const getEventIdForApi: (event: any) => string;
+/**
+ * Verifica si un evento es una ocurrencia de un evento recurrente
+ *
+ * @param event - El evento a verificar
+ * @returns true si es una ocurrencia recurrente
+ */
+export declare const isRecurringOccurrence: (event: any) => boolean;
+/**
+ * Obtiene el ID para eliminar una ocurrencia específica de un evento recurrente.
+ * Para una ocurrencia específica, usa el ID completo (con sufijo).
+ * Para eliminar todas las ocurrencias, usa getEventIdForApi.
+ *
+ * @param event - El evento a eliminar
+ * @param deleteAll - Si debe eliminar todas las ocurrencias o solo esta
+ * @returns El ID apropiado para la operación de eliminación
+ */
+export declare const getEventIdForDelete: (event: any, deleteAll?: boolean) => string;

package/dist/types/components/EventsDialog/utils/eventValidation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Utilidades para validación de eventos del calendario
+ */
+export interface CalendarItem {
+    id?: string;
+    start: Date | string;
+    end: Date | string;
+    title?: string;
+    kind?: 'event' | 'task';
+}
+/**
+ * Verifica si dos eventos se solapan en el tiempo
+ */
+export declare const eventsOverlap: (event1: CalendarItem, event2: CalendarItem) => boolean;
+/**
+ * Encuentra todos los eventos que se solapan con un evento dado
+ */
+export declare const findOverlappingEvents: (targetEvent: CalendarItem, allEvents: CalendarItem[]) => CalendarItem[];
+/**
+ * Valida que un evento tenga fechas válidas
+ */
+export declare const validateEventDates: (event: CalendarItem) => {
+    isValid: boolean;
+    error?: string;
+};
+/**
+ * Genera un mensaje descriptivo sobre eventos solapados
+ */
+export declare const getOverlapWarningMessage: (overlappingEvents: CalendarItem[]) => string;
+/**
+ * Calcula la duración de un evento en minutos
+ */
+export declare const getEventDuration: (event: CalendarItem) => number;
+/**
+ * Verifica si un evento es de todo el día
+ */
+export declare const isAllDayEvent: (event: CalendarItem) => boolean;

package/dist/types/components/EventsDialog/utils/googleMapsLoader.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Utilidad para cargar la API de Google Maps de manera asincrónica
+ * Este archivo proporciona una forma centralizada y asincrónica de cargar Google Maps
+ * para evitar problemas de rendimiento y advertencias de la consola.
+ */
+export declare const GOOGLE_MAPS_CONFIG: {
+    apiKey: string;
+    libraries: string[];
+    loading: string;
+};
+export declare const GOOGLE_MAPS_SCRIPT_CONFIG: {
+    apiKey: string;
+    libraries: string[];
+    loading: string;
+};
+/**
+ * Hook para asegurar que los scripts de Google Maps se carguen correctamente
+ * antes de inicializar componentes que dependan de ellos
+ */
+export declare const useGoogleMapsLoader: () => {
+    isLoaded: boolean;
+    error: Error | null;
+};
+/**
+ * Carga la API de Google Maps de manera asincrónica
+ * @param apiKey - La clave de API de Google Maps
+ * @param libraries - Bibliotecas opcionales para cargar (como array)
+ * @returns Una promesa que se resuelve cuando la API se ha cargado correctamente
+ */
+export declare const loadGoogleMapsAsync: (apiKey?: string, libraries?: string[] | string) => Promise<void>;
+/**
+ * Genera una URL para el mapa estático de Google Maps
+ * @param latitude - Latitud del centro del mapa
+ * @param longitude - Longitud del centro del mapa
+ * @param zoom - Nivel de zoom (1-20)
+ * @param width - Ancho de la imagen en píxeles
+ * @param height - Alto de la imagen en píxeles
+ * @param markerColor - Color del marcador (por ejemplo, "red", "blue")
+ * @param apiKey - Clave de API de Google Maps (opcional, usa la predeterminada si no se proporciona)
+ * @returns URL del mapa estático
+ */
+export declare const getStaticMapUrl: (latitude: number | string, longitude: number | string, zoom?: number, width?: number, height?: number, markerColor?: string, apiKey?: string) => string;
+/**
+ * Geocodifica una dirección para obtener sus coordenadas
+ * @param address - La dirección a geocodificar
+ * @returns Una promesa que resuelve a un objeto con lat y lng, o null si ocurre un error
+ */
+export declare const geocodeAddress: (address: string) => Promise<{
+    lat: string;
+    lng: string;
+} | null>;

package/dist/types/components/EventsDialog/utils/isNumber.d.ts

@@ -0,0 +1 @@
+export declare function isNumber(valor: any): valor is number;

package/dist/types/components/EventsDialog/utils/keyboardNavigation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utilidades para navegación por teclado en el calendario
+ */
+import { View } from 'react-big-calendar';
+export interface KeyboardNavigationConfig {
+    onNavigate: (action: 'PREV' | 'NEXT' | 'TODAY' | 'DATE', date?: Date) => void;
+    onViewChange: (view: View) => void;
+    onCreateEvent?: () => void;
+    currentDate: Date;
+    currentView: View;
+}
+/**
+ * Maneja los eventos de teclado para el calendario
+ */
+export declare const handleCalendarKeyDown: (event: KeyboardEvent, config: KeyboardNavigationConfig) => void;
+/**
+ * Genera el mensaje de ayuda para atajos de teclado
+ */
+export declare const getKeyboardShortcutsHelp: () => string;
+/**
+ * Genera los atributos ARIA para el calendario
+ */
+export declare const getCalendarAriaAttributes: (currentView: View, currentDate: Date) => Record<string, string>;

package/dist/types/components/EventsDialog/utils/roundTime.d.ts

@@ -0,0 +1,10 @@
+import { Dayjs } from 'dayjs';
+/**
+ * Redondea una fecha al siguiente intervalo de 30 minutos
+ * Ejemplos:
+ * - 16:55 → 17:00
+ * - 16:23 → 16:30
+ * - 16:45 → 17:00
+ * - 16:30 → 16:30 (ya está redondeado)
+ */
+export declare function roundToNext30Minutes(date: Dayjs | Date): Dayjs;

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

@@ -0,0 +1,5 @@
+export { default as ContactInfoPopup } from './ContactInfoPopup';
+export { default as EditContactModal } from './EditContactModal';
+export { default as EventsDialog } from './EventsDialog';
+export type { EventsDialogProps, EventData, TaskData } from './EventsDialog';
+export type { ModalMode, ItemType, Calendar, Contact, Notification } from './EventsDialog/types';

package/dist/types/i18n/config.d.ts

@@ -0,0 +1,2 @@
+declare const i18nInstance: import("i18next").i18n;
+export default i18nInstance;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { default as i18n } from './config';
+export { useTranslation } from 'react-i18next';

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export { i18n } from './i18n';