@consilioweb/payload-support 2.0.0 → 3.0.0

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

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface RichTextEditorHandle {
+    clear: () => void;
+    setContent: (html: string) => void;
+    getHtml: () => string;
+    getPlainText: () => string;
+    focus: () => void;
+}
+interface Props {
+    initialValue?: string;
+    onChange: (html: string, plainText: string) => void;
+    placeholder?: string;
+    minHeight?: number;
+    onFileUpload?: (file: File) => Promise<string | null>;
+    borderColor?: string;
+    focusBorderColor?: string;
+}
+export declare const RichTextEditor: React.ForwardRefExoticComponent<Props & React.RefAttributes<RichTextEditorHandle>>;
+export {};

package/dist/components/TicketConversation/RewriteDropdown.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const RewriteDropdown: React.FC<{
+    disabled: boolean;
+    loading: boolean;
+    onSelect: (style: string) => void;
+}>;

package/dist/components/TicketConversation/SkeletonText.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare function SkeletonText({ lines }: {
+    lines?: number;
+}): React.JSX.Element;

package/dist/components/TicketConversation/components/AISummaryPanel.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface AISummaryPanelProps {
+    showAiSummary: boolean;
+    setShowAiSummary: (v: boolean) => void;
+    aiSummary: string;
+    aiGenerating: boolean;
+    aiSaving: boolean;
+    aiSaved: boolean;
+    handleAiGenerate: () => void;
+    handleAiSave: () => void;
+}
+export declare function renderAiSummary(summary: string): React.ReactNode[];
+export declare function AISummaryPanel({ showAiSummary, setShowAiSummary, aiSummary, aiGenerating, aiSaving, aiSaved, handleAiGenerate, handleAiSave, }: AISummaryPanelProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/ActionPanels.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+interface MergePanelProps {
+    mergeTarget: string;
+    setMergeTarget: (v: string) => void;
+    mergeTargetInfo: {
+        id: number;
+        ticketNumber: string;
+        subject: string;
+    } | null;
+    setMergeTargetInfo: (v: null) => void;
+    mergeError: string;
+    setMergeError: (v: string) => void;
+    merging: boolean;
+    handleMergeLookup: () => void;
+    handleMerge: () => void;
+}
+export declare function MergePanel({ mergeTarget, setMergeTarget, mergeTargetInfo, setMergeTargetInfo, mergeError, setMergeError, merging, handleMergeLookup, handleMerge, }: MergePanelProps): React.JSX.Element;
+interface ExtMessagePanelProps {
+    extMsgBody: string;
+    setExtMsgBody: (v: string) => void;
+    extMsgAuthor: 'client' | 'admin';
+    setExtMsgAuthor: (v: 'client' | 'admin') => void;
+    extMsgDate: string;
+    setExtMsgDate: (v: string) => void;
+    extMsgFiles: File[];
+    setExtMsgFiles: React.Dispatch<React.SetStateAction<File[]>>;
+    sendingExtMsg: boolean;
+    handleSendExtMsg: () => void;
+    handleExtFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export declare function ExtMessagePanel({ extMsgBody, setExtMsgBody, extMsgAuthor, setExtMsgAuthor, extMsgDate, setExtMsgDate, extMsgFiles, setExtMsgFiles, sendingExtMsg, handleSendExtMsg, handleExtFileChange, }: ExtMessagePanelProps): React.JSX.Element;
+interface ReminderPanelProps {
+    clientFirstName: string;
+    clientEmail: string;
+    reminderHours: number;
+    setReminderHours: (v: number) => void;
+    reminderSending: boolean;
+    reminderError: string;
+    handleSendReminder: () => void;
+}
+export declare function ReminderPanel({ clientFirstName, clientEmail, reminderHours, setReminderHours, reminderSending, reminderError, handleSendReminder, }: ReminderPanelProps): React.JSX.Element;
+interface SnoozePanelProps {
+    snoozeSaving: boolean;
+    handleSnooze: (days: number | null, customDate?: string) => void;
+}
+export declare function SnoozePanel({ snoozeSaving, handleSnooze }: SnoozePanelProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/ActivityLog.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ActivityEntry } from '../types.js';
+export declare function ActivityLog({ activityLog }: {
+    activityLog: ActivityEntry[];
+}): React.JSX.Element;

package/dist/components/TicketConversation/components/ClientBar.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ClientInfo } from '../types.js';
+export declare function ClientBar({ client }: {
+    client: ClientInfo;
+}): React.JSX.Element;

package/dist/components/TicketConversation/components/ClientHistory.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { ClientInfo } from '../types.js';
+interface ClientHistoryProps {
+    client: ClientInfo;
+    clientTickets: Array<{
+        id: number;
+        ticketNumber: string;
+        subject: string;
+        status: string;
+        createdAt: string;
+    }>;
+    clientProjects: Array<{
+        id: number;
+        name: string;
+        status: string;
+    }>;
+    clientNotes: string;
+    onNotesChange: (notes: string) => void;
+    onNotesSave: () => void;
+    savingNotes: boolean;
+    notesSaved: boolean;
+}
+export declare function ClientHistory({ client: _client, clientTickets, clientProjects, clientNotes, onNotesChange, onNotesSave, savingNotes, notesSaved, }: ClientHistoryProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/CodeBlock.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+/**
+ * Checks if text contains fenced code blocks.
+ */
+export declare function hasCodeBlocks(text: string): boolean;
+/**
+ * Renders the FULL message text, replacing fenced code blocks with styled components.
+ * Use this INSTEAD of rendering msg.body directly when code blocks are present.
+ */
+export declare function MessageWithCodeBlocks({ text, style }: {
+    text: string;
+    style?: React.CSSProperties;
+}): React.JSX.Element;
+/**
+ * For HTML content: strips tags (preserving newlines), then renders with code blocks.
+ */
+export declare function MessageWithCodeBlocksHtml({ html, style }: {
+    html: string;
+    style?: React.CSSProperties;
+}): React.JSX.Element | null;
+export declare function CodeBlockRenderer({ text }: {
+    text: string;
+}): React.JSX.Element | null;
+export declare function CodeBlockRendererHtml({ html }: {
+    html: string;
+}): React.JSX.Element;

package/dist/components/TicketConversation/components/CodeBlockInserter.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface CodeBlockInserterProps {
+    onInsert: (block: string) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Toolbar button that opens a language picker dropdown.
+ * When a language is selected, calls onInsert with the fenced code block template.
+ */
+export declare function CodeBlockInserter({ onInsert, className, style }: CodeBlockInserterProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/QuickActions.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+interface QuickActionsProps {
+    statusTransitions: Array<{
+        status: string;
+        label: string;
+        color: string;
+    }>;
+    statusUpdating: boolean;
+    onStatusChange: (status: string) => void;
+    snoozeUntil: string | null;
+    snoozeSaving: boolean;
+    onCancelSnooze: () => void;
+    showMerge: boolean;
+    showExtMsg: boolean;
+    showSnooze: boolean;
+    onToggleMerge: () => void;
+    onToggleExtMsg: () => void;
+    onToggleSnooze: () => void;
+    onNextTicket: () => void;
+    showReminderButton: boolean;
+    onToggleReminder: () => void;
+    autoCloseScheduledAt: string | null;
+    onCancelScheduledClose: () => void;
+    cancelingClose: boolean;
+    reminderSuccess: boolean;
+    showNextTicket: boolean;
+    nextTicketId: number | null;
+    nextTicketInfo: string;
+    onCloseNextTicket: () => void;
+}
+export declare function QuickActions({ statusTransitions, statusUpdating, onStatusChange, snoozeUntil, snoozeSaving, onCancelSnooze, showMerge: _showMerge, showExtMsg: _showExtMsg, showSnooze: _showSnooze, onToggleMerge, onToggleExtMsg, onToggleSnooze, onNextTicket, showReminderButton, onToggleReminder, autoCloseScheduledAt, onCancelScheduledClose, cancelingClose, reminderSuccess, showNextTicket, nextTicketId, nextTicketInfo, onCloseNextTicket, }: QuickActionsProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/TicketHeader.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { SatisfactionSurvey } from '../types.js';
+interface TicketHeaderProps {
+    ticketNumber: string;
+    currentStatus: string;
+    clientSentiment: {
+        emoji: string;
+        label: string;
+        color: string;
+    } | null;
+    ticketSource: string;
+    chatSession: string;
+    snoozeUntil: string | null;
+    satisfaction: SatisfactionSurvey | null;
+    copiedLink: 'admin' | 'client' | null;
+    onCopyLink: (type: 'admin' | 'client') => void;
+}
+export declare function TicketHeader({ ticketNumber, currentStatus, clientSentiment, ticketSource, chatSession, snoozeUntil, satisfaction, copiedLink, onCopyLink, }: TicketHeaderProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/components/TimeTrackingPanel.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { TimeEntry } from '../types.js';
+interface TimeTrackingPanelProps {
+    timeEntries: TimeEntry[];
+    totalMinutes: number;
+    timerRunning: boolean;
+    timerSeconds: number;
+    setTimerSeconds: React.Dispatch<React.SetStateAction<number>>;
+    timerDescription: string;
+    setTimerDescription: (v: string) => void;
+    handleTimerStart: (reset?: boolean) => void;
+    handleTimerStop: () => void;
+    handleTimerSave: () => void;
+    handleTimerDiscard: () => void;
+    duration: string;
+    setDuration: (v: string) => void;
+    timeDescription: string;
+    setTimeDescription: (v: string) => void;
+    handleAddTime: () => void;
+    addingTime: boolean;
+    timeSuccess: string;
+}
+export declare function TimeTrackingPanel({ timeEntries, totalMinutes, timerRunning, timerSeconds, setTimerSeconds, timerDescription, setTimerDescription, handleTimerStart, handleTimerStop, handleTimerSave, handleTimerDiscard, duration, setDuration, timeDescription, setTimeDescription, handleAddTime, addingTime, timeSuccess, }: TimeTrackingPanelProps): React.JSX.Element;
+export {};

package/dist/components/TicketConversation/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ticketing feature flags — re-export of the shared implementation.
+ *
+ * The flags used to be defined (twice, byte-for-byte) here and in
+ * `views/shared/config.ts`, each reading `localStorage` directly. The single
+ * implementation now lives in `utils/features.ts` and is backed by the server;
+ * both modules are kept as import sites so existing paths keep working.
+ */
+export { DEFAULT_TICKETING_FEATURES, DEFAULT_TICKETING_FEATURES as DEFAULT_FEATURES, FEATURES_CACHE_KEY, fetchFeatures, getFeatures, normalizeFeatures, saveFeatures, } from '../../utils/features.js';
+export type { TicketingFeatures } from '../../utils/features.js';

package/dist/components/TicketConversation/config.js

@@ -1,41 +1,2 @@
 "use client";
-const DEFAULT_FEATURES = {
-  timeTracking: true,
-  ai: true,
-  satisfaction: true,
-  chat: true,
-  emailTracking: true,
-  canned: true,
-  merge: true,
-  snooze: true,
-  externalMessages: true,
-  clientHistory: true,
-  activityLog: true,
-  splitTicket: true,
-  scheduledReplies: true,
-  autoClose: true,
-  autoCloseDays: 7,
-  roundRobin: false
-};
-const STORAGE_KEY = "ticketing_features";
-function getFeatures() {
-  if (typeof window === "undefined") return DEFAULT_FEATURES;
-  try {
-    const stored = localStorage.getItem(STORAGE_KEY);
-    if (stored) {
-      const parsed = JSON.parse(stored);
-      return { ...DEFAULT_FEATURES, ...parsed };
-    }
-  } catch {
-  }
-  return DEFAULT_FEATURES;
-}
-function saveFeatures(features) {
-  if (typeof window === "undefined") return;
-  try {
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(features));
-  } catch {
-  }
-}
-
-export { DEFAULT_FEATURES, getFeatures, saveFeatures };
+export { DEFAULT_TICKETING_FEATURES as DEFAULT_FEATURES, DEFAULT_TICKETING_FEATURES, FEATURES_CACHE_KEY, fetchFeatures, getFeatures, normalizeFeatures, saveFeatures } from '../../utils/features.js';

package/dist/components/TicketConversation/constants.d.ts

@@ -0,0 +1,56 @@
+import type React from 'react';
+export declare const REWRITE_STYLES: {
+    id: string;
+    label: string;
+    desc: string;
+}[];
+export declare const layoutStyles: {
+    root: React.CSSProperties;
+    twoColumns: React.CSSProperties;
+    mainColumn: React.CSSProperties;
+    sideColumn: React.CSSProperties;
+};
+export declare const statusLabels: Record<string, {
+    label: string;
+    bg: string;
+    color: string;
+}>;
+export declare const projectStatusLabels: Record<string, {
+    label: string;
+    bg: string;
+    color: string;
+}>;
+export declare const C: {
+    blue: string;
+    amber: string;
+    orange: string;
+    black: string;
+    white: string;
+    bg: string;
+    textPrimary: string;
+    textSecondary: string;
+    textMuted: string;
+    border: string;
+    statusOpen: string;
+    statusProgress: string;
+    statusWaiting: string;
+    statusResolved: string;
+    statusClosed: string;
+    adminBg: string;
+    adminBorder: string;
+    clientBg: string;
+    clientBorder: string;
+    emailBg: string;
+    emailBorder: string;
+    internalBg: string;
+    internalBorder: string;
+};
+export declare const s: {
+    section: React.CSSProperties;
+    sectionTitle: React.CSSProperties;
+    btn: (bg: string, disabled?: boolean) => React.CSSProperties;
+    ghostBtn: (color: string, disabled?: boolean) => React.CSSProperties;
+    outlineBtn: (color: string, disabled?: boolean) => React.CSSProperties;
+    input: React.CSSProperties;
+    badge: (bg: string, color: string) => React.CSSProperties;
+};

package/dist/components/TicketConversation/context.d.ts

@@ -0,0 +1,53 @@
+import type { Message, TimeEntry, ClientInfo, CannedResponse, ActivityEntry, SatisfactionSurvey } from './types.js';
+/**
+ * Handle interface for the RichTextEditor component.
+ * When used inside the plugin, the consumer must provide a compatible editor
+ * or leave the ref unused.
+ */
+export interface RichTextEditorHandle {
+    setContent: (html: string) => void;
+    clear: () => void;
+    focus: () => void;
+}
+export interface TicketContextValue {
+    id: string | number | undefined;
+    messages: Message[];
+    timeEntries: TimeEntry[];
+    client: ClientInfo | null;
+    cannedResponses: CannedResponse[];
+    activityLog: ActivityEntry[];
+    satisfaction: SatisfactionSurvey | null;
+    loading: boolean;
+    currentStatus: string;
+    ticketNumber: string;
+    ticketSubject: string;
+    ticketSource: string;
+    chatSession: string;
+    snoozeUntil: string | null;
+    lastClientReadAt: string | null;
+    clientTickets: Array<{
+        id: number;
+        ticketNumber: string;
+        subject: string;
+        status: string;
+        createdAt: string;
+    }>;
+    clientProjects: Array<{
+        id: number;
+        name: string;
+        status: string;
+    }>;
+    clientNotes: string;
+    clientSentiment: {
+        emoji: string;
+        label: string;
+        color: string;
+    } | null;
+    clientTyping: boolean;
+    clientTypingName: string;
+    fetchAll: () => void;
+    sendAdminTyping: () => void;
+    replyEditorRef: React.RefObject<RichTextEditorHandle | null>;
+}
+export declare const TicketContext: import("react").Context<TicketContextValue | null>;
+export declare function useTicketContext(): TicketContextValue;

package/dist/components/TicketConversation/hooks/useAI.d.ts

@@ -0,0 +1,21 @@
+import type { Message, ClientInfo } from '../types.js';
+import type { RichTextEditorHandle } from '../context.js';
+export declare function useAI(messages: Message[], client: ClientInfo | null, ticketSubject: string, replyBody: string, setReplyBody: (v: string) => void, setReplyHtml: (v: string) => void, replyEditorRef: React.RefObject<RichTextEditorHandle | null>): {
+    clientSentiment: {
+        emoji: string;
+        label: string;
+        color: string;
+    } | null;
+    aiReplying: boolean;
+    handleAiSuggestReply: () => Promise<void>;
+    aiRewriting: boolean;
+    handleAiRewrite: (style?: string) => Promise<void>;
+    showAiSummary: boolean;
+    setShowAiSummary: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    aiSummary: string;
+    aiGenerating: boolean;
+    handleAiGenerate: () => Promise<void>;
+    aiSaving: boolean;
+    aiSaved: boolean;
+    handleAiSave: (id: string | number | undefined, fetchAll: () => void) => Promise<void>;
+};

package/dist/components/TicketConversation/hooks/useDocumentIdFromUrl.d.ts

@@ -0,0 +1,3 @@
+export declare function useDocumentIdFromUrl(): {
+    id: string | number | undefined;
+};

package/dist/components/TicketConversation/hooks/useFeatures.d.ts

@@ -0,0 +1,23 @@
+import { type TicketingFeatures } from '../../../utils/features.js';
+export interface UseFeaturesResult {
+    /** Current flags — cached values on first paint, server values once loaded. */
+    features: TicketingFeatures;
+    /** True until the first server round-trip settles. */
+    loading: boolean;
+    /** True when the server could not be reached and cached/default values are shown. */
+    offline: boolean;
+    /** Replace the flags locally without persisting (for a settings form). */
+    setFeatures: (features: TicketingFeatures) => void;
+    /** Persist the flags server-side. Resolves to false when the write failed. */
+    save: (features: TicketingFeatures) => Promise<boolean>;
+}
+/**
+ * Read the ticketing feature flags from the server, with the local cache as a
+ * fallback so a screen never blocks on the settings call.
+ *
+ * Also performs the one-shot migration of pre-2.1 installs: when this browser
+ * still holds flags in `localStorage` and the server has never had any saved,
+ * the local values are pushed up once and become the shared truth. Afterwards
+ * the server always wins and `localStorage` is only a cache.
+ */
+export declare function useFeatures(): UseFeaturesResult;

package/dist/components/TicketConversation/hooks/useFeatures.js

@@ -0,0 +1,61 @@
+"use client";
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { getFeatures, fetchFeatures, readLegacyFeatures, saveFeatures, markLegacyFeaturesAdopted, hasAdoptedLegacyFeatures, writeFeaturesCache } from '../../../utils/features.js';
+
+function useFeatures() {
+  const [features, setFeatures] = useState(() => getFeatures());
+  const [loading, setLoading] = useState(true);
+  const [offline, setOffline] = useState(false);
+  const migrationAttempted = useRef(false);
+  const dirty = useRef(false);
+  useEffect(() => {
+    const controller = new AbortController();
+    let cancelled = false;
+    void (async () => {
+      const result = await fetchFeatures(controller.signal);
+      if (cancelled) return;
+      if (!result.offline && !result.configured && !migrationAttempted.current && !dirty.current) {
+        migrationAttempted.current = true;
+        const legacy = readLegacyFeatures();
+        if (legacy) {
+          const ok = await saveFeatures(legacy);
+          if (cancelled) return;
+          if (ok) {
+            markLegacyFeaturesAdopted();
+            setFeatures(legacy);
+            setLoading(false);
+            return;
+          }
+        }
+      }
+      if (!result.offline && !hasAdoptedLegacyFeatures()) {
+        markLegacyFeaturesAdopted();
+      }
+      if (!dirty.current) setFeatures(result.features);
+      setOffline(result.offline);
+      setLoading(false);
+    })();
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, []);
+  const setLocalFeatures = useCallback((next) => {
+    dirty.current = true;
+    setFeatures(next);
+    writeFeaturesCache(next);
+  }, []);
+  const save = useCallback(async (next) => {
+    const ok = await saveFeatures(next);
+    if (ok) {
+      markLegacyFeaturesAdopted();
+      dirty.current = false;
+      setFeatures(next);
+      setOffline(false);
+    }
+    return ok;
+  }, []);
+  return { features, loading, offline, setFeatures: setLocalFeatures, save };
+}
+
+export { useFeatures };

package/dist/components/TicketConversation/hooks/useMessageActions.d.ts

@@ -0,0 +1,20 @@
+import type { Message, ClientInfo } from '../types.js';
+export declare function useMessageActions(id: string | number | undefined, client: ClientInfo | null, fetchAll: () => void): {
+    togglingAuthor: string | number | null;
+    editingMsg: string | number | null;
+    editBody: string;
+    editHtml: string;
+    setEditHtml: import("react").Dispatch<import("react").SetStateAction<string>>;
+    savingEdit: boolean;
+    handleEditStart: (msg: Message) => void;
+    handleEditSave: (msgId: string | number) => Promise<void>;
+    handleEditCancel: () => void;
+    deletingMsg: string | number | null;
+    handleDelete: (msgId: string | number) => Promise<void>;
+    resendingMsg: string | number | null;
+    resendSuccess: string | number | null;
+    handleResend: (msgId: string | number) => Promise<void>;
+    handleToggleAuthor: (msgId: string | number, currentType: string) => Promise<void>;
+    handleSplitMessage: (msgId: string | number, ticketSubject: string) => Promise<void>;
+    setEditBody: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/dist/components/TicketConversation/hooks/useReply.d.ts

@@ -0,0 +1,27 @@
+import type { ClientInfo, CannedResponse } from '../types.js';
+import type { RichTextEditorHandle } from '../context.js';
+export declare function useReply(id: string | number | undefined, client: ClientInfo | null, cannedResponses: CannedResponse[], ticketNumber: string, ticketSubject: string, fetchAll: () => void, handleNextTicket: () => void, replyEditorRef: React.RefObject<RichTextEditorHandle | null>): {
+    fileInputRef: import("react").RefObject<HTMLInputElement | null>;
+    replyBody: string;
+    setReplyBody: import("react").Dispatch<import("react").SetStateAction<string>>;
+    replyHtml: string;
+    setReplyHtml: import("react").Dispatch<import("react").SetStateAction<string>>;
+    replyFiles: File[];
+    setReplyFiles: import("react").Dispatch<import("react").SetStateAction<File[]>>;
+    isInternal: boolean;
+    setIsInternal: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    notifyClient: boolean;
+    setNotifyClient: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    sendAsClient: boolean;
+    setSendAsClient: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    sending: boolean;
+    showSchedule: boolean;
+    setShowSchedule: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    scheduleDate: string;
+    setScheduleDate: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleEditorFileUpload: (file: File) => Promise<string | null>;
+    handleCannedSelect: (e: React.ChangeEvent<HTMLSelectElement>) => void;
+    handleReplyFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleSendReply: () => Promise<void>;
+    handleScheduleReply: () => Promise<void>;
+};

package/dist/components/TicketConversation/hooks/useTicketActions.d.ts

@@ -0,0 +1,58 @@
+export declare function useTicketActions(id: string | number | undefined, fetchAll: () => void): {
+    statusUpdating: boolean;
+    handleStatusChange: (newStatus: string) => Promise<void>;
+    showMerge: boolean;
+    setShowMerge: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    mergeTarget: string;
+    setMergeTarget: import("react").Dispatch<import("react").SetStateAction<string>>;
+    mergeTargetInfo: {
+        id: number;
+        ticketNumber: string;
+        subject: string;
+    } | null;
+    setMergeTargetInfo: import("react").Dispatch<import("react").SetStateAction<{
+        id: number;
+        ticketNumber: string;
+        subject: string;
+    } | null>>;
+    mergeError: string;
+    setMergeError: import("react").Dispatch<import("react").SetStateAction<string>>;
+    merging: boolean;
+    handleMergeLookup: () => Promise<void>;
+    handleMerge: () => Promise<void>;
+    showExtMsg: boolean;
+    setShowExtMsg: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    extMsgBody: string;
+    setExtMsgBody: import("react").Dispatch<import("react").SetStateAction<string>>;
+    extMsgAuthor: "client" | "admin";
+    setExtMsgAuthor: import("react").Dispatch<import("react").SetStateAction<"client" | "admin">>;
+    extMsgDate: string;
+    setExtMsgDate: import("react").Dispatch<import("react").SetStateAction<string>>;
+    extMsgFiles: File[];
+    setExtMsgFiles: import("react").Dispatch<import("react").SetStateAction<File[]>>;
+    sendingExtMsg: boolean;
+    handleExtFileChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleSendExtMsg: () => Promise<void>;
+    showSnooze: boolean;
+    setShowSnooze: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    snoozeUntil: string | null;
+    setSnoozeUntil: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    snoozeSaving: boolean;
+    handleSnooze: (days: number | null, customDate?: string) => Promise<void>;
+    showReminder: boolean;
+    setShowReminder: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    reminderHours: number;
+    setReminderHours: import("react").Dispatch<import("react").SetStateAction<number>>;
+    reminderSending: boolean;
+    reminderError: string;
+    setReminderError: import("react").Dispatch<import("react").SetStateAction<string>>;
+    reminderSuccess: boolean;
+    handleSendReminder: () => Promise<void>;
+    cancelingClose: boolean;
+    handleCancelScheduledClose: () => Promise<void>;
+    showNextTicket: boolean;
+    setShowNextTicket: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    nextTicketId: number | null;
+    nextTicketInfo: string;
+    handleNextTicket: () => Promise<void>;
+};

package/dist/components/TicketConversation/hooks/useTimeTracking.d.ts

@@ -0,0 +1,18 @@
+export declare function useTimeTracking(id: string | number | undefined, fetchAll: () => void): {
+    duration: string;
+    setDuration: import("react").Dispatch<import("react").SetStateAction<string>>;
+    timeDescription: string;
+    setTimeDescription: import("react").Dispatch<import("react").SetStateAction<string>>;
+    addingTime: boolean;
+    timeSuccess: string;
+    timerRunning: boolean;
+    timerSeconds: number;
+    setTimerSeconds: import("react").Dispatch<import("react").SetStateAction<number>>;
+    timerDescription: string;
+    setTimerDescription: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleAddTime: () => Promise<void>;
+    handleTimerStart: (reset?: boolean) => void;
+    handleTimerStop: () => void;
+    handleTimerSave: () => Promise<void>;
+    handleTimerDiscard: () => void;
+};