@trii/components 2.0.101 → 2.0.102

package/dist/types/components/ContactSidebar/context/SidebarIdentityContext.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { UserInfo, UserTrii } from '@trii/types/dist/Users';
+import { Spaces } from '@trii/types';
+import { ISpaceInfo } from '@trii/types/dist/Spaces';
+/**
+ * Identidad de la sesión: quién soy, quiénes son los agentes del espacio, en
+ * qué espacio estoy y cómo firmo las URLs de media. Antes llegaban por props
+ * (currentUser, users, contactNameFormat, resolveMediaUrl) porque el host los
+ * tenía en Redux; acá se resuelven contra la API con el baseUrl + spaceId del
+ * contrato. Migra al paquete tal cual.
+ */
+export interface SidebarUser {
+    uid: string;
+    name: string;
+    imageUrl?: string;
+    /** Preferencias de formato del usuario (regCon_* del UserTrii). */
+    dateFormat?: string;
+    timeFormat?: string;
+}
+export interface SidebarIdentityValue {
+    currentUser: SidebarUser | null;
+    /**
+     * Usuario crudo de la API. Lo necesita el parcel de combinar contactos, que
+     * espera el UserTrii completo; el resto del árbol usa currentUser.
+     */
+    currentUserTrii: UserTrii | null;
+    /** Agentes del espacio: nombres de autores, presencia y "compartir con". */
+    users: UserInfo[];
+    contactNameFormat: Spaces.nameFormat | undefined;
+    /** Espacio completo (idem: lo pide el parcel de combinar contactos). */
+    spaceInfo: ISpaceInfo | null;
+    /** Firma una URL de media con el token SAS de la sesión. */
+    resolveMediaUrl: (url: string) => Promise<string>;
+}
+export declare const SidebarIdentityProvider: ({ children, }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useSidebarIdentity(): SidebarIdentityValue;
+/** Solo para tests: descarta la identidad cacheada entre casos. */
+export declare function __resetIdentityCache(): void;

package/dist/types/components/ContactSidebar/context/SidebarPropsContext.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="react" />
+import { IConversation } from '@trii/types/dist/Conversations';
+import { IBusiness, IContact, IContactAddress } from '@trii/types/dist/Contacts';
+import { ChannelType } from '@trii/types/dist/Common/Channels';
+/**
+ * Contrato de entrada del sidebar (docs/CONTRATO_CHATDETAILSSIDEBAR.md).
+ * El container del host resuelve estos valores desde Redux; el árbol interno
+ * los consume desde acá en lugar de tocar el store del host. Al migrar el
+ * sidebar a @trii/components, este context viaja con él tal cual.
+ */
+export interface SidebarApiConfig {
+    /** Raíz de la API (ej: https://agent-api.trii.app/api/v1), sin servicio ni spaceId. */
+    baseUrl: string;
+    spaceId: string;
+}
+/**
+ * Integración con un inbox de chat. Es opcional: sin ella el sidebar funciona
+ * en "modo ficha" (sin GroupData, sin abrir conversaciones, sin iniciar una
+ * conversación por canal), que es como se monta fuera del inbox.
+ */
+export interface SidebarChatIntegration {
+    /** Conversación seleccionada en el host (tab conversaciones, GroupData). */
+    conversation: IConversation | null;
+    /** Abrir/cambiar a una conversación del contacto en el inbox. */
+    onOpenConversation: (conversation: IConversation) => Promise<void> | void;
+    /** Navegar/scrollear a un mensaje en el body del chat. */
+    onNavigateToMessage: (messageId: string) => void;
+    /** "Chatear por este canal/dirección": arma el composer del host. */
+    onStartConversation: (target: StartConversationTarget) => void;
+    /** La conversación cambió (grupo WA editado): el host sincroniza Redux + Dexie. */
+    onConversationUpdated: (conversation: IConversation) => void;
+    /** El usuario salió del grupo: el host cierra/limpia la conversación. */
+    onGroupLeft: (conversationId: string) => void;
+}
+export interface SidebarProps {
+    api: SidebarApiConfig;
+    contactId: string | null;
+    entityType: 'contact' | 'business';
+    /**
+     * false cuando el host no pasó `chat`: los callbacks de abajo son no-ops y la
+     * UI que depende del inbox se deshabilita.
+     */
+    hasChatIntegration: boolean;
+    /**
+     * Ficha ya resuelta por el host, si la tiene: solo siembra el estado inicial
+     * para que no parpadee. El sidebar la fetchea igual (SidebarEntityContext).
+     */
+    initialEntity?: IContact | IBusiness | null;
+    /** Conversación seleccionada en el host, si hay (tab conversaciones, GroupData). */
+    conversation: IConversation | null;
+    /** Para el EditContactModal embebido (búsqueda de direcciones). */
+    googleMapsApiKey?: string;
+    /**
+     * Navegación del anfitrión. Sin ella se usa window.location.assign: los
+     * destinos son rutas de otro microfront, no internas del sidebar.
+     */
+    navigate?: (path: string) => void;
+    /** Abrir/cambiar a una conversación del contacto en el inbox. */
+    onOpenConversation: (conversation: IConversation) => Promise<void> | void;
+    /** Navegar/scrollear a un mensaje en el body del chat. */
+    onNavigateToMessage: (messageId: string) => void;
+    /**
+     * El contacto/empresa cambió (edición, convert, etc.): el host sincroniza su
+     * estado. Es no-op si el host no la pasó.
+     */
+    onEntityUpdated: (entity: IContact | IBusiness) => void;
+    /** La conversación cambió (grupo WA editado): el host sincroniza Redux + Dexie. */
+    onConversationUpdated: (conversation: IConversation) => void;
+    /** El usuario salió del grupo: el host cierra/limpia la conversación. */
+    onGroupLeft: (conversationId: string) => void;
+    /** "Chatear por este canal/dirección": arma el composer del host. */
+    onStartConversation: (target: StartConversationTarget) => void;
+}
+export interface StartConversationTarget {
+    channelType: ChannelType;
+    addressId: string;
+    address: IContactAddress | undefined;
+    addressList: IContactAddress[];
+}
+export declare const SidebarPropsProvider: import("react").Provider<SidebarProps>;
+export declare function useSidebarProps(): SidebarProps;

package/dist/types/components/ContactSidebar/context/types/ActivitiesCardContextType.d.ts

@@ -0,0 +1,29 @@
+import { IEvent, ITask } from '@trii/types/dist/Calendar';
+import { UseCreateActivityType } from '../../hooks/useCreateActivity';
+import { ActivitiesTableColumn } from './ActivitiesTableColumn';
+import { TabName } from './TabName';
+import { ActivitiesTableColumnName } from '../../types/activities';
+export type ActivitiesCardContextType = {
+    isCreatePopUpOpen: boolean;
+    activeModalType: 'event' | 'task' | null;
+    columns: ActivitiesTableColumn[];
+    newActivity: UseCreateActivityType;
+    isEditing: boolean;
+    setIsEditing: (isEditing: boolean) => void;
+    sortByColumn: (columnName: ActivitiesTableColumnName, sortOrder: 'ASC' | 'DESC') => void;
+    openEditActivityPopUp: (event: IEvent | ITask, type: 'event' | 'task') => void;
+    openCreateActivityPopUp: (type: 'event' | 'task') => void;
+    closeActivityPopUp: () => void;
+    handleDeleteActivity: (activityId: string, type?: 'event' | 'task') => void;
+    showDetails: boolean;
+    setShowDetails: (showDetails: boolean) => void;
+    selectedActivity: IEvent | ITask | null;
+    tabsShowed: TabName[];
+    setTabsShowed: (tabsShowed: TabName[]) => void;
+    contactId?: string;
+    handleActionComplete: (payload: {
+        action: 'create' | 'update' | 'delete' | 'duplicate';
+        itemType: 'event' | 'task';
+        data?: any;
+    }) => void;
+};

package/dist/types/components/ContactSidebar/context/types/ActivitiesTableColumn.d.ts

@@ -0,0 +1,7 @@
+import { ActivitiesTableColumnName } from '../../types/activities';
+export type ActivitiesTableColumn = {
+    name: ActivitiesTableColumnName;
+    title: string;
+    sorted: boolean;
+    sortDirection: 'ASC' | 'DESC';
+};

package/dist/types/components/ContactSidebar/context/types/TabName.d.ts

@@ -0,0 +1 @@
+export type TabName = 'contactConversation' | 'contactData' | 'contactEvent' | 'contactFiles' | 'contactHistory' | 'contactNotes' | 'contactRepairs' | 'contactTicket' | 'contactButtons' | 'contactPanelShop' | 'contactGroupData' | string;

package/dist/types/components/ContactSidebar/context/utils/columns.d.ts

@@ -0,0 +1,2 @@
+import { ActivitiesTableColumn } from '../types/ActivitiesTableColumn';
+export declare const activitiesTableColumns: ActivitiesTableColumn[];

package/dist/types/components/ContactSidebar/hooks/useActivitiesCardContext.d.ts

@@ -0,0 +1,2 @@
+import { ActivitiesCardContextType } from '../context/types/ActivitiesCardContextType';
+export declare const useActivitiesCardContext: () => ActivitiesCardContextType;

package/dist/types/components/ContactSidebar/hooks/useActivityDate.d.ts

@@ -0,0 +1,31 @@
+import { Dispatch, SetStateAction } from 'react';
+import { Dayjs } from 'dayjs';
+export declare const useActivityDateInitialDef: {
+    state: {
+        error: boolean;
+        selectedStartDate: any;
+        selectedEndDate: any;
+    };
+    action: {
+        setError: () => void;
+        setSelectedStartDate: () => void;
+        setSelectedEndDate: () => void;
+        handleSelect: () => () => void;
+        resetDates: () => void;
+    };
+};
+export type UseActivityDateType = {
+    state: {
+        error: boolean;
+        selectedStartDate: Dayjs;
+        selectedEndDate: Dayjs;
+    };
+    action: {
+        setError: Dispatch<SetStateAction<boolean>>;
+        setSelectedStartDate: Dispatch<SetStateAction<Dayjs>>;
+        setSelectedEndDate: Dispatch<SetStateAction<Dayjs>>;
+        handleSelect: (setState: Dispatch<SetStateAction<Dayjs>>) => (date: Dayjs) => void;
+        resetDates: () => void;
+    };
+};
+export declare function useActivityDate(startDate?: Date, endDate?: Date): UseActivityDateType;

package/dist/types/components/ContactSidebar/hooks/useCreateActivity.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="react" />
+import { UseFieldType } from './useField';
+import { UseActivityDateType } from './useActivityDate';
+import { UseNotificationsType } from './useNotifications';
+import { UseLinkContactsType } from './useLinkContacts';
+import { IEvent, ITask } from '@trii/types/dist/Calendar';
+export declare const useCreateActivityInitialDef: {
+    field: {
+        title: UseFieldType;
+        description: UseFieldType;
+        date: {
+            state: {
+                error: boolean;
+                selectedStartDate: any;
+                selectedEndDate: any;
+            };
+            action: {
+                setError: () => void;
+                setSelectedStartDate: () => void;
+                setSelectedEndDate: () => void;
+                handleSelect: () => () => void;
+                resetDates: () => void;
+            };
+        };
+        notifications: {
+            notifications: any[];
+            action: {
+                addNotification: () => void;
+                deleteNotification: (notificationId: string) => void;
+                handleTimeFieldChange: (event: import("react").ChangeEvent<HTMLInputElement | HTMLTextAreaElement>, notificationId: string) => void;
+                handleTimePeriodChange: (event: import("@mui/material").SelectChangeEvent<unknown>, notificationId: string) => void;
+                handleReminderChange: (event: import("react").ChangeEvent<HTMLInputElement>, notificationId: string) => void;
+                resetNotifications: () => void;
+            };
+        };
+        shareWithUsers: {
+            users: any[];
+            field: {
+                userIds: any[];
+                handleChange: (event: import("@mui/material").SelectChangeEvent<string[]>) => void;
+            };
+            action: {
+                resetField: () => void;
+                getUserNameById: (userId: string) => string;
+            };
+        };
+        linkContact: {
+            state: {
+                isLoading: boolean;
+                contactSelectedId: any;
+                search: string;
+            };
+            action: {
+                resetField: () => void;
+                handleSearch: (value: string) => void;
+                handleScroll: (e: import("react").UIEvent<HTMLElement, UIEvent>) => void;
+                handleSelectContact: (contact: import("@trii/types/dist/Contacts").IContact) => void;
+            };
+            contactList: any[];
+        };
+    };
+    action: {
+        resetFields: () => void;
+        getActivity: () => void;
+    };
+};
+export type UseCreateActivityType = {
+    field: {
+        title: UseFieldType;
+        description: UseFieldType;
+        date: UseActivityDateType;
+        notifications: UseNotificationsType;
+        linkContact: UseLinkContactsType;
+    };
+    action: {
+        resetFields: () => void;
+        getActivity: () => any;
+    };
+};
+export declare function useCreateActivity(activity?: IEvent | ITask | null): UseCreateActivityType;

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

@@ -0,0 +1,18 @@
+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;
+    };
+}
+declare const useField: (type: string, initialValue?: string) => UseFieldType;
+export default useField;

package/dist/types/components/ContactSidebar/hooks/useInfiniteScroll.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Scroll infinito: dispara el callback al llegar al fondo bajando.
+ * Copia de hooks/useInfiniteScroll del host (viaja al paquete).
+ */
+type InfiniteScrollCallback = () => Promise<void>;
+export declare function useInfiniteScroll(callback: InfiniteScrollCallback): (e: React.UIEvent<HTMLDivElement>) => Promise<void>;
+export default useInfiniteScroll;

package/dist/types/components/ContactSidebar/hooks/useLinkContacts.d.ts

@@ -0,0 +1,31 @@
+import { IContact, IContactInfo } from '@trii/types/dist/Contacts';
+import { UIEvent } from 'react';
+export declare const useLinkContactsInitialDef: {
+    state: {
+        isLoading: boolean;
+        contactSelectedId: any;
+        search: string;
+    };
+    action: {
+        resetField: () => void;
+        handleSearch: (value: string) => void;
+        handleScroll: (e: UIEvent<HTMLElement>) => void;
+        handleSelectContact: (contact: IContact) => void;
+    };
+    contactList: any[];
+};
+export type UseLinkContactsType = {
+    state: {
+        isLoading: boolean;
+        contactSelectedId: string;
+        search: string;
+    };
+    action: {
+        resetField: () => void;
+        handleSearch: (value: string) => void;
+        handleScroll: (e: UIEvent<HTMLElement>) => void;
+        handleSelectContact: (contactId: IContact) => void;
+    };
+    contactList: IContactInfo[];
+};
+export declare function useLinkContacts(contactId?: string): UseLinkContactsType;

package/dist/types/components/ContactSidebar/hooks/useMultipleSelect.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+export type UseMultipleSelectReturnType<T> = {
+    attributes: {
+        value: T;
+        onChange: (event: any, newValue: T) => void;
+    };
+    actions: {
+        addValue: (newValue: any) => void;
+        setValue: (newValue: T) => void;
+    };
+};
+export declare function useMultipleSelect<T>(name: string, initialValue: T[]): {
+    name: string;
+    value: T[];
+    setValue: import("react").Dispatch<import("react").SetStateAction<T[]>>;
+    attributes: {
+        value: T[];
+        onChange: (_event: any, newValue: T[]) => void;
+    };
+    actions: {
+        addValue: (item: T) => void;
+        removeValue: (item: T) => void;
+        clearValues: () => void;
+        setValue: import("react").Dispatch<import("react").SetStateAction<T[]>>;
+    };
+};

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

@@ -0,0 +1,27 @@
+import { ChangeEvent } from 'react';
+import { EventNotificationFront } from '../types/activities';
+import { IEventNotification } from '@trii/types/dist/Calendar';
+import { SelectChangeEvent } from '@mui/material';
+export declare const useNotificationsInitialDef: {
+    notifications: any[];
+    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/ContactSidebar/hooks/useSectionRefs.d.ts

@@ -0,0 +1,19 @@
+import { RefObject } from 'react';
+export interface SectionRefs {
+    contactDataRef: RefObject<HTMLElement | null>;
+    contactConversationRef: RefObject<HTMLElement | null>;
+    contactTicketRef: RefObject<HTMLElement | null>;
+    contactNotesRef: RefObject<HTMLElement | null>;
+    contactRepairsRef: RefObject<HTMLElement | null>;
+    contactFilesRef: RefObject<HTMLElement | null>;
+    contactMediaRef: RefObject<HTMLElement | null>;
+    contactHistoryRef: RefObject<HTMLElement | null>;
+    contactEventRef: RefObject<HTMLElement | null>;
+    contactTaskRef: RefObject<HTMLElement | null>;
+    contactButtonsRef: RefObject<HTMLElement | null>[];
+    contactPanelShopRef: RefObject<HTMLElement | null>;
+    contactRelationsRef: RefObject<HTMLElement | null>;
+    groupDataRef: RefObject<HTMLDivElement | null>;
+}
+declare function useSectionRefs(buttonsData?: any[] | null): SectionRefs;
+export default useSectionRefs;

package/dist/types/components/ContactSidebar/hooks/useShareWithUsers.d.ts

@@ -0,0 +1,25 @@
+import { SelectChangeEvent } from '@mui/material';
+import { UserInfo } from '@trii/types/dist/Users';
+export declare const useShareWithUsersInitialDef: {
+    users: any[];
+    field: {
+        userIds: any[];
+        handleChange: (event: SelectChangeEvent<string[]>) => void;
+    };
+    action: {
+        resetField: () => void;
+        getUserNameById: (userId: string) => string;
+    };
+};
+export type UseShareWithUsersType = {
+    users: UserInfo[];
+    field: {
+        userIds: string[];
+        handleChange: (event: SelectChangeEvent<string[]>) => void;
+    };
+    action: {
+        resetField: () => void;
+        getUserNameById: (userId: string) => string;
+    };
+};
+export declare function useShareWithUsers(sharedUserIds?: string[]): UseShareWithUsersType;

package/dist/types/components/ContactSidebar/hooks/useSidebarAudioControl.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+/**
+ * Exclusión mutua de reproducción de audio, sin Redux.
+ *
+ * El host coordinaba esto con audioSlice (useGlobalAudioControl), lo que ataba
+ * el sidebar a su store. Acá se hace con un evento del DOM, patrón que el repo
+ * ya usa (GroupInformationBox dispara 'call-contact-chat'): quien empieza a
+ * sonar avisa, y todos los demás reproductores se pausan.
+ *
+ * El bridge del host (hooks/useGlobalAudioControl) emite y escucha el mismo
+ * evento, así que la exclusión sigue funcionando entre el sidebar y el chat.
+ */
+export declare const AUDIO_PLAY_EVENT = "trii:audio-play";
+export interface AudioPlayEventDetail {
+    audioId: string;
+    source: string;
+}
+interface UseSidebarAudioControlProps {
+    audioId: string;
+    source: string;
+    waveformRef: React.MutableRefObject<any | null>;
+    isPlaying: boolean;
+    setIsPlaying: (playing: boolean) => void;
+}
+export declare function useSidebarAudioControl({ audioId, source, waveformRef, isPlaying, setIsPlaying, }: UseSidebarAudioControlProps): {
+    requestAudioPlayback: () => void;
+    stopAudio: () => void;
+    pauseAudio: () => void;
+    isThisAudioPlaying: boolean;
+};
+export default useSidebarAudioControl;

package/dist/types/components/ContactSidebar/hooks/useSidebarMediaUrl.d.ts

@@ -0,0 +1,4 @@
+/** Devuelve el resolvedor de URLs con token de la sesión. */
+export declare function useResolveMediaUrl(): (url: string) => Promise<string>;
+/** Reemplazo interno de useSASAvatarURL: URL con token o '' mientras resuelve. */
+export declare function useSidebarMediaUrl(imageUrl: string): string;

package/dist/types/components/ContactSidebar/hooks/useSidebarNavigate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Navegación del sidebar. Reemplaza al useNavigate de react-router, que ataba
+ * el árbol a que existiera un Router del host: el destino se delega al
+ * anfitrión por la prop `navigate` del contrato.
+ *
+ * Sin esa prop cae a window.location.assign, que sirve porque los destinos
+ * reales son rutas de OTRO microfront (/a/contacts/...), no rutas internas.
+ */
+export declare function useSidebarNavigate(): (path: string) => void;
+export default useSidebarNavigate;

package/dist/types/components/ContactSidebar/i18n/SidebarI18nProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * Monta la instancia propia del sidebar para todo el subárbol. Como
+ * I18nextProvider pisa la instancia del context, los ~142 `useTranslation()`
+ * del árbol resuelven contra estas claves sin tocar ningún componente.
+ *
+ * El idioma llega por prop porque, al tener instancia propia, el sidebar deja
+ * de seguir automáticamente los cambios de idioma del anfitrión.
+ */
+interface SidebarI18nProviderProps {
+    language?: string;
+    children: ReactNode;
+}
+export declare const SidebarI18nProvider: ({ language, children, }: SidebarI18nProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default SidebarI18nProvider;

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

@@ -0,0 +1,4 @@
+declare const sidebarI18n: import("i18next").i18n;
+/** Normaliza lo que venga del anfitrión ('ES', 'En', 'es-AR', ...). */
+export declare function normalizeLanguage(language?: string): 'en' | 'es';
+export default sidebarI18n;

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

@@ -0,0 +1,3 @@
+export { default as ContactSidebar } from './ChatDetailsSidebar';
+export { default } from './ChatDetailsSidebar';
+export type { ChatDetailsSidebarProps as ContactSidebarProps, SidebarChatIntegration, StartConversationTarget, } from './ChatDetailsSidebar';

package/dist/types/components/ContactSidebar/services/buttonsApi.d.ts

@@ -0,0 +1,15 @@
+import { IIntegrationButton } from '@trii/types/dist/Contacts';
+import { SidebarApiConfig } from '../context/SidebarPropsContext';
+/**
+ * Service interno del sidebar para la configuración de secciones/botones
+ * de integración del panel (antes buttonsSlice, que era sidebar-only).
+ */
+type ApiArgs = SidebarApiConfig & {
+    signal?: AbortSignal;
+};
+export declare function fetchButtons({ baseUrl, spaceId, signal, }: ApiArgs): Promise<IIntegrationButton[]>;
+export declare function fetchButtonData({ baseUrl, spaceId, buttonId, contactId, signal, }: ApiArgs & {
+    buttonId: number;
+    contactId: string;
+}): Promise<unknown>;
+export {};

package/dist/types/components/ContactSidebar/services/calendarApi.d.ts

@@ -0,0 +1,32 @@
+import { IEvent, ITask } from '@trii/types/dist/Calendar';
+import { SidebarApiConfig } from '../context/SidebarPropsContext';
+/**
+ * Service interno del sidebar para eventos y tareas del calendario.
+ * Nota: la creación/edición vive en EventsDialog (@trii/components);
+ * acá solo lectura, refresh por id y borrado.
+ */
+type ApiArgs = SidebarApiConfig & {
+    signal?: AbortSignal;
+};
+/** Ventana del mes en curso, igual que el thunk fetchActivities del host. */
+export declare function fetchEvents({ baseUrl, spaceId, contactId, signal, }: ApiArgs & {
+    contactId?: string;
+}): Promise<IEvent[]>;
+export declare function fetchEventById({ baseUrl, spaceId, eventId, signal, }: ApiArgs & {
+    eventId: string;
+}): Promise<IEvent>;
+export declare function deleteEvent({ baseUrl, spaceId, eventId, originalOccurrenceDate, signal, }: ApiArgs & {
+    eventId: string;
+    /** Para eventos recurrentes: borra solo esa ocurrencia. */
+    originalOccurrenceDate?: Date | string;
+}): Promise<void>;
+export declare function fetchTasks({ baseUrl, spaceId, contactId, signal, }: ApiArgs & {
+    contactId?: string;
+}): Promise<ITask[]>;
+export declare function fetchTaskById({ baseUrl, spaceId, taskId, signal, }: ApiArgs & {
+    taskId: string;
+}): Promise<ITask>;
+export declare function deleteTask({ baseUrl, spaceId, taskId, signal, }: ApiArgs & {
+    taskId: string;
+}): Promise<void>;
+export {};