@hubspot/ui-extensions 0.12.4 → 0.13.1

package/dist/__tests__/test-d/extension-points.test-d.js

@@ -5,6 +5,7 @@ expectAssignable({
         addAlert: () => { },
         copyTextToClipboard: async () => { },
         closeOverlay: () => { },
+        navigateToPage: () => { },
         reloadPage: () => { },
         openIframeModal: () => { },
     },

package/dist/crm/hooks/useAssociations.d.ts

@@ -1,10 +1,10 @@
-import { type PaginationResult } from '../../utils/pagination.ts';
+import type { PaginationResult } from '../../shared/types/hooks.ts';
 import type { AssociationResult, FetchAssociationsRequest } from '../utils/fetchAssociations.ts';
 import { type FetchCrmPropertiesOptions } from '../utils/fetchCrmProperties.ts';
-export interface UseAssociationsOptions {
+export type UseAssociationsOptions = {
     propertiesToFormat?: 'all' | string[];
     formattingOptions?: FetchCrmPropertiesOptions['formattingOptions'];
-}
+};
 export interface UseAssociationsResult {
     results: AssociationResult[];
     error: Error | null;

package/dist/crm/hooks/useAssociations.js

@@ -1,15 +1,15 @@
-import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
-import { createMockAwareHook } from "../../internal/hook-utils.js";
+import { useCallback, useReducer, useState } from 'react';
+import { useFetchLifecycle } from "../../hooks/utils/useFetchLifecycle.js";
+import { createMockAwareHook, useStableValue, } from "../../internal/hook-utils.js";
 import { calculatePaginationFlags, DEFAULT_PAGE_SIZE, } from "../../utils/pagination.js";
 import { fetchAssociations } from "../utils/fetchAssociations.js";
-function createInitialState(pageSize) {
+function createInitialState() {
     return {
         results: [],
         error: null,
         isLoading: true,
         isRefetching: false,
         currentPage: 1,
-        pageSize,
         hasMore: false,
         currentOffset: undefined,
         nextOffset: undefined,
@@ -71,6 +71,7 @@ function associationsReducer(state, action) {
                 ...state,
                 currentPage: 1,
                 results: [],
+                isLoading: true,
                 hasMore: false,
                 error: null,
                 currentOffset: undefined,
@@ -108,40 +109,18 @@ const DEFAULT_OPTIONS = {};
  */
 function useAssociationsInternal(config, options = DEFAULT_OPTIONS) {
     const pageSize = config?.pageLength ?? DEFAULT_PAGE_SIZE;
-    const [state, dispatch] = useReducer(associationsReducer, useMemo(() => createInitialState(pageSize), [pageSize]));
+    const [state, dispatch] = useReducer(associationsReducer, createInitialState());
     /**
-     * HOOK OPTIMIZATION:
-     *
-     * Create stable references for config and options to prevent unnecessary re-renders and API calls.
-     * Then, external developers can pass inline objects without worrying about memoization
-     * We handle the deep equality comparison ourselves, and return the same object reference when content is equivalent.
+     * Reset pagination when pageSize changes.
+     * Render-phase update (not useEffect) avoids committing a render with stale paginated results.
      */
-    const lastConfigRef = useRef();
-    const lastConfigKeyRef = useRef();
-    const lastOptionsRef = useRef();
-    const lastOptionsKeyRef = useRef();
-    // Track in-flight refetch to support cancellation
-    const refetchAbortRef = useRef(null);
-    // Track refetch cleanup function to prevent memory leaks
-    const refetchCleanupRef = useRef(null);
-    const stableConfig = useMemo(() => {
-        const configKey = JSON.stringify(config);
-        if (configKey === lastConfigKeyRef.current) {
-            return lastConfigRef.current;
-        }
-        lastConfigKeyRef.current = configKey;
-        lastConfigRef.current = config;
-        return config;
-    }, [config]);
-    const stableOptions = useMemo(() => {
-        const optionsKey = JSON.stringify(options);
-        if (optionsKey === lastOptionsKeyRef.current) {
-            return lastOptionsRef.current;
-        }
-        lastOptionsKeyRef.current = optionsKey;
-        lastOptionsRef.current = options;
-        return options;
-    }, [options]);
+    const [prevPageSize, setPrevPageSize] = useState(pageSize);
+    if (prevPageSize !== pageSize) {
+        setPrevPageSize(pageSize);
+        dispatch({ type: 'RESET' });
+    }
+    const stableConfig = useStableValue(config);
+    const stableOptions = useStableValue(options);
     // Pagination actions
     const nextPage = useCallback(() => {
         const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
@@ -156,122 +135,59 @@ function useAssociationsInternal(config, options = DEFAULT_OPTIONS) {
         }
     }, [state.currentPage, state.hasMore]);
     const reset = useCallback(() => {
-        dispatch({ type: 'RESET' });
-    }, []);
-    // Fetch the associations
-    useEffect(() => {
-        let cancelled = false;
-        let cleanup = null;
-        const fetchData = async () => {
-            try {
-                dispatch({ type: 'FETCH_START' });
-                // Build request using current offset token
-                const request = {
-                    toObjectType: stableConfig?.toObjectType,
-                    properties: stableConfig?.properties,
-                    pageLength: pageSize,
-                    offset: state.currentOffset,
-                };
-                const result = await fetchAssociations(request, {
-                    propertiesToFormat: stableOptions.propertiesToFormat,
-                    formattingOptions: stableOptions.formattingOptions,
-                });
-                if (!cancelled) {
-                    dispatch({
-                        type: 'FETCH_SUCCESS',
-                        payload: {
-                            results: result.data.results,
-                            hasMore: result.data.hasMore,
-                            nextOffset: result.data.nextOffset,
-                            currentOffset: state.currentOffset,
-                        },
-                    });
-                    cleanup = result.cleanup;
-                }
-            }
-            catch (err) {
-                if (!cancelled) {
-                    const errorData = err instanceof Error
-                        ? err
-                        : new Error('Failed to fetch associations');
-                    dispatch({ type: 'FETCH_ERROR', payload: errorData });
-                }
-            }
-        };
-        fetchData();
-        return () => {
-            cancelled = true;
-            // Call cleanup function to release resources
-            if (cleanup) {
-                cleanup();
-            }
-            // Clean up any active refetch subscription
-            if (refetchCleanupRef.current) {
-                refetchCleanupRef.current();
-                refetchCleanupRef.current = null;
-            }
-        };
-    }, [
-        stableConfig,
-        stableOptions,
-        state.currentPage,
-        state.currentOffset,
-        pageSize,
-    ]);
-    const refetch = useCallback(async () => {
-        if (refetchAbortRef.current) {
-            refetchAbortRef.current.cancelled = true;
-        }
-        if (refetchCleanupRef.current) {
-            refetchCleanupRef.current();
-            refetchCleanupRef.current = null;
+        const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
+        // Only reset to first page if we're not already on the first page
+        if (paginationFlags.hasPreviousPage) {
+            dispatch({ type: 'RESET' });
         }
-        const abortSignal = { cancelled: false };
-        refetchAbortRef.current = abortSignal;
-        try {
-            dispatch({ type: 'REFETCH_START' });
-            // Build request using current offset token to refetch current page
+    }, [state.currentPage, state.hasMore]);
+    const { refetch } = useFetchLifecycle({
+        fetchFn: () => {
             const request = {
                 toObjectType: stableConfig?.toObjectType,
                 properties: stableConfig?.properties,
                 pageLength: pageSize,
                 offset: state.currentOffset,
             };
-            const result = await fetchAssociations(request, {
+            return fetchAssociations(request, {
                 propertiesToFormat: stableOptions.propertiesToFormat,
                 formattingOptions: stableOptions.formattingOptions,
             });
-            if (!abortSignal.cancelled) {
-                dispatch({
+        },
+        callbacks: {
+            onStart: ({ isRefetch }) => dispatch({ type: isRefetch ? 'REFETCH_START' : 'FETCH_START' }),
+            onSuccess: (data, { isRefetch }) => dispatch(isRefetch
+                ? {
                     type: 'REFETCH_SUCCESS',
                     payload: {
-                        results: result.data.results,
-                        hasMore: result.data.hasMore,
-                        nextOffset: result.data.nextOffset,
+                        results: data.results,
+                        hasMore: data.hasMore,
+                        nextOffset: data.nextOffset,
                     },
-                });
-                refetchCleanupRef.current = result.cleanup;
-            }
-            else {
-                if (result.cleanup) {
-                    result.cleanup();
                 }
-            }
-        }
-        catch (err) {
-            if (!abortSignal.cancelled) {
-                const errorData = err instanceof Error
-                    ? err
-                    : new Error('Failed to refetch associations');
-                dispatch({ type: 'REFETCH_ERROR', payload: errorData });
-            }
-        }
-        finally {
-            if (refetchAbortRef.current === abortSignal) {
-                refetchAbortRef.current = null;
-            }
-        }
-    }, [stableConfig, stableOptions, state.currentOffset, pageSize]);
+                : {
+                    type: 'FETCH_SUCCESS',
+                    payload: {
+                        results: data.results,
+                        hasMore: data.hasMore,
+                        nextOffset: data.nextOffset,
+                        currentOffset: state.currentOffset,
+                    },
+                }),
+            onError: (error, { isRefetch }) => dispatch({
+                type: isRefetch ? 'REFETCH_ERROR' : 'FETCH_ERROR',
+                payload: error,
+            }),
+        },
+        deps: [
+            stableConfig,
+            stableOptions,
+            state.currentPage,
+            state.currentOffset,
+            pageSize,
+        ],
+        defaultErrorMessage: 'Failed to fetch associations',
+    });
     // Calculate pagination flags
     const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
     return {
@@ -284,7 +200,7 @@ function useAssociationsInternal(config, options = DEFAULT_OPTIONS) {
             hasNextPage: paginationFlags.hasNextPage,
             hasPreviousPage: paginationFlags.hasPreviousPage,
             currentPage: state.currentPage,
-            pageSize: state.pageSize,
+            pageSize,
             nextPage,
             previousPage,
             reset,

package/dist/crm/hooks/useCrmProperties.js

@@ -1,5 +1,6 @@
-import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
-import { createMockAwareHook } from "../../internal/hook-utils.js";
+import { useMemo, useReducer } from 'react';
+import { useFetchLifecycle } from "../../hooks/utils/useFetchLifecycle.js";
+import { createMockAwareHook, useStableValue, } from "../../internal/hook-utils.js";
 import { fetchCrmProperties } from "../utils/fetchCrmProperties.js";
 const initialState = {
     properties: {},
@@ -58,130 +59,33 @@ const DEFAULT_OPTIONS = {};
  */
 function useCrmPropertiesInternal(propertyNames, options = DEFAULT_OPTIONS) {
     const [state, dispatch] = useReducer(crmPropertiesReducer, initialState);
-    /**
-     * HOOK OPTIMIZATION:
-     *
-     * Create stable references for propertyNames and options to prevent unnecessary re-renders and API calls.
-     * Then, external developers can pass inline arrays/objects without worrying about memoization
-     * We handle the deep equality comparison ourselves, and return the same object reference when content is equivalent.
-     */
-    const lastPropertyNamesRef = useRef();
-    const lastPropertyNamesKeyRef = useRef();
-    const lastOptionsRef = useRef();
-    const lastOptionsKeyRef = useRef();
-    // Track in-flight refetch to support cancellation
-    const refetchAbortRef = useRef(null);
-    // Track refetch cleanup function to prevent memory leaks
-    const refetchCleanupRef = useRef(null);
-    const stablePropertyNames = useMemo(() => {
-        if (!Array.isArray(propertyNames)) {
-            return propertyNames;
-        }
-        const sortedNames = [...propertyNames].sort();
-        const propertyNamesKey = JSON.stringify(sortedNames);
-        if (propertyNamesKey === lastPropertyNamesKeyRef.current) {
-            return lastPropertyNamesRef.current;
-        }
-        lastPropertyNamesKeyRef.current = propertyNamesKey;
-        lastPropertyNamesRef.current = sortedNames;
-        return sortedNames;
-    }, [propertyNames]);
-    const stableOptions = useMemo(() => {
-        const optionsKey = JSON.stringify(options);
-        if (optionsKey === lastOptionsKeyRef.current) {
-            return lastOptionsRef.current;
-        }
-        lastOptionsKeyRef.current = optionsKey;
-        lastOptionsRef.current = options;
-        return options;
-    }, [options]);
-    // Fetch the properties
-    useEffect(() => {
-        let cancelled = false;
-        let cleanup = null;
-        const fetchData = async () => {
-            try {
-                dispatch({ type: 'FETCH_START' });
-                const result = await fetchCrmProperties(stablePropertyNames, (data) => {
-                    if (!cancelled) {
-                        dispatch({ type: 'FETCH_SUCCESS', payload: data });
-                    }
-                }, stableOptions);
-                if (!cancelled) {
-                    dispatch({ type: 'FETCH_SUCCESS', payload: result.data });
-                    cleanup = result.cleanup;
-                }
+    // Sort property names so that order doesn't matter for cache keys
+    const sortedPropertyNames = useMemo(() => Array.isArray(propertyNames) ? [...propertyNames].sort() : propertyNames, [propertyNames]);
+    const stablePropertyNames = useStableValue(sortedPropertyNames);
+    const stableOptions = useStableValue(options);
+    const { refetch } = useFetchLifecycle({
+        fetchFn: (signal) => fetchCrmProperties(stablePropertyNames, (data) => {
+            if (!signal.cancelled) {
+                dispatch({
+                    type: signal.isRefetch ? 'REFETCH_SUCCESS' : 'FETCH_SUCCESS',
+                    payload: data,
+                });
             }
-            catch (err) {
-                if (!cancelled) {
-                    const errorData = err instanceof Error
-                        ? err
-                        : new Error('Failed to fetch CRM properties');
-                    dispatch({ type: 'FETCH_ERROR', payload: errorData });
-                }
-            }
-        };
-        fetchData();
-        return () => {
-            cancelled = true;
-            // Call cleanup function to release RPC resources
-            if (cleanup) {
-                cleanup();
-            }
-            // Clean up any active refetch subscription
-            if (refetchCleanupRef.current) {
-                refetchCleanupRef.current();
-                refetchCleanupRef.current = null;
-            }
-        };
-    }, [stablePropertyNames, stableOptions]);
-    const refetch = useCallback(async () => {
-        // Cancel any in-flight refetch
-        if (refetchAbortRef.current) {
-            refetchAbortRef.current.cancelled = true;
-        }
-        // Clean up old refetch subscription to prevent memory leaks
-        if (refetchCleanupRef.current) {
-            refetchCleanupRef.current();
-            refetchCleanupRef.current = null;
-        }
-        // Create new abort signal for this refetch
-        const abortSignal = { cancelled: false };
-        refetchAbortRef.current = abortSignal;
-        try {
-            dispatch({ type: 'REFETCH_START' });
-            const result = await fetchCrmProperties(stablePropertyNames, (data) => {
-                if (!abortSignal.cancelled) {
-                    dispatch({ type: 'REFETCH_SUCCESS', payload: data });
-                }
-            }, stableOptions);
-            if (!abortSignal.cancelled) {
-                dispatch({ type: 'REFETCH_SUCCESS', payload: result.data });
-                // Store cleanup for next refetch or unmount
-                refetchCleanupRef.current = result.cleanup;
-            }
-            else {
-                // If cancelled, clean up immediately
-                if (result.cleanup) {
-                    result.cleanup();
-                }
-            }
-        }
-        catch (err) {
-            if (!abortSignal.cancelled) {
-                const errorData = err instanceof Error
-                    ? err
-                    : new Error('Failed to refetch CRM properties');
-                dispatch({ type: 'REFETCH_ERROR', payload: errorData });
-            }
-        }
-        finally {
-            // Clear the abort ref if this is still the current refetch
-            if (refetchAbortRef.current === abortSignal) {
-                refetchAbortRef.current = null;
-            }
-        }
-    }, [stablePropertyNames, stableOptions]);
+        }, stableOptions),
+        callbacks: {
+            onStart: ({ isRefetch }) => dispatch({ type: isRefetch ? 'REFETCH_START' : 'FETCH_START' }),
+            onSuccess: (data, { isRefetch }) => dispatch({
+                type: isRefetch ? 'REFETCH_SUCCESS' : 'FETCH_SUCCESS',
+                payload: data,
+            }),
+            onError: (error, { isRefetch }) => dispatch({
+                type: isRefetch ? 'REFETCH_ERROR' : 'FETCH_ERROR',
+                payload: error,
+            }),
+        },
+        deps: [stablePropertyNames, stableOptions],
+        defaultErrorMessage: 'Failed to fetch CRM properties',
+    });
     return {
         ...state,
         refetch,

package/dist/crm/utils/fetchAssociations.js

@@ -28,9 +28,6 @@ export const fetchAssociations = async (request, options) => {
     if (result.error) {
         throw new Error(result.error);
     }
-    if (!response.ok) {
-        throw new Error(`Failed to fetch associations: ${response.statusText}`);
-    }
     if (!isAssociationsResponse(result.data)) {
         throw new Error('Invalid response format');
     }

package/dist/experimental/hooks/useCrmSearch.d.ts

@@ -0,0 +1,2 @@
+import type { FetchCrmSearchRequest, UseCrmSearchOptions, UseCrmSearchResult } from '../../shared/types/hooks.ts';
+export declare function useCrmSearch(config: Omit<FetchCrmSearchRequest, 'after'>, options?: UseCrmSearchOptions): UseCrmSearchResult;

package/dist/experimental/hooks/useCrmSearch.js

@@ -0,0 +1,206 @@
+import { useCallback, useReducer, useState } from 'react';
+import { useFetchLifecycle } from "../../hooks/utils/useFetchLifecycle.js";
+import { useStableValue } from "../../internal/hook-utils.js";
+import { calculatePaginationFlags, DEFAULT_PAGE_SIZE, } from "../../utils/pagination.js";
+import { fetchCrmSearch } from "./utils/fetchCrmSearch.js";
+function createInitialState() {
+    return {
+        results: [],
+        total: 0,
+        error: null,
+        isLoading: true,
+        isRefetching: false,
+        currentPage: 1,
+        hasMore: false,
+        currentCursor: undefined,
+        nextCursor: undefined,
+        offsetHistory: [],
+    };
+}
+function crmSearchReducer(state, action) {
+    switch (action.type) {
+        case 'FETCH_START':
+            return {
+                ...state,
+                isLoading: true,
+                error: null,
+            };
+        case 'FETCH_SUCCESS':
+            return {
+                ...state,
+                isLoading: false,
+                results: action.payload.results,
+                total: action.payload.total,
+                hasMore: action.payload.hasMore,
+                currentCursor: action.payload.currentCursor,
+                nextCursor: action.payload.nextCursor,
+                error: null,
+            };
+        case 'FETCH_ERROR':
+            return {
+                ...state,
+                isLoading: false,
+                error: action.payload,
+                results: [],
+                total: 0,
+                hasMore: false,
+                currentCursor: undefined,
+                nextCursor: undefined,
+            };
+        case 'NEXT_PAGE':
+            return {
+                ...state,
+                currentPage: state.currentPage + 1,
+                offsetHistory: state.currentCursor !== undefined
+                    ? [...state.offsetHistory, state.currentCursor]
+                    : state.offsetHistory,
+                currentCursor: state.nextCursor,
+                nextCursor: undefined,
+            };
+        case 'PREVIOUS_PAGE': {
+            const newPage = Math.max(1, state.currentPage - 1);
+            const newHistory = [...state.offsetHistory];
+            const previousCursor = newHistory.pop();
+            return {
+                ...state,
+                currentPage: newPage,
+                offsetHistory: newHistory,
+                currentCursor: previousCursor,
+                nextCursor: undefined,
+            };
+        }
+        case 'RESET':
+            return {
+                ...state,
+                currentPage: 1,
+                results: [],
+                total: 0,
+                isLoading: true,
+                hasMore: false,
+                error: null,
+                currentCursor: undefined,
+                nextCursor: undefined,
+                offsetHistory: [],
+            };
+        case 'REFETCH_START':
+            return {
+                ...state,
+                isRefetching: true,
+                error: null,
+            };
+        case 'REFETCH_SUCCESS':
+            return {
+                ...state,
+                isRefetching: false,
+                results: action.payload.results,
+                total: action.payload.total,
+                hasMore: action.payload.hasMore,
+                nextCursor: action.payload.nextCursor,
+                error: null,
+            };
+        case 'REFETCH_ERROR':
+            return {
+                ...state,
+                isRefetching: false,
+                error: action.payload,
+            };
+        default:
+            return state;
+    }
+}
+const DEFAULT_OPTIONS = {};
+export function useCrmSearch(config, options = DEFAULT_OPTIONS) {
+    const pageSize = config?.pageSize ?? DEFAULT_PAGE_SIZE;
+    const [state, dispatch] = useReducer(crmSearchReducer, createInitialState());
+    // Reset pagination when pageSize changes.
+    // Render-phase update (not useEffect) avoids committing a render with stale paginated results.
+    const [prevPageSize, setPrevPageSize] = useState(pageSize);
+    if (prevPageSize !== pageSize) {
+        setPrevPageSize(pageSize);
+        dispatch({ type: 'RESET' });
+    }
+    const stableConfig = useStableValue(config);
+    const stableOptions = useStableValue(options);
+    const nextPage = useCallback(() => {
+        const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
+        if (paginationFlags.hasNextPage) {
+            dispatch({ type: 'NEXT_PAGE' });
+        }
+    }, [state.currentPage, state.hasMore]);
+    const previousPage = useCallback(() => {
+        const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
+        if (paginationFlags.hasPreviousPage) {
+            dispatch({ type: 'PREVIOUS_PAGE' });
+        }
+    }, [state.currentPage, state.hasMore]);
+    const reset = useCallback(() => {
+        const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
+        if (paginationFlags.hasPreviousPage) {
+            dispatch({ type: 'RESET' });
+        }
+    }, [state.currentPage, state.hasMore]);
+    const { refetch } = useFetchLifecycle({
+        fetchFn: () => {
+            const request = {
+                objectType: stableConfig?.objectType,
+                properties: stableConfig?.properties,
+                query: stableConfig?.query,
+                filterGroups: stableConfig?.filterGroups,
+                sorts: stableConfig?.sorts,
+                pageSize,
+                after: state.currentCursor,
+            };
+            return fetchCrmSearch(request, {
+                propertiesToFormat: stableOptions.propertiesToFormat,
+                formattingOptions: stableOptions.formattingOptions,
+            });
+        },
+        callbacks: {
+            onStart: ({ isRefetch }) => dispatch({ type: isRefetch ? 'REFETCH_START' : 'FETCH_START' }),
+            onSuccess: (data, { isRefetch }) => dispatch(isRefetch
+                ? {
+                    type: 'REFETCH_SUCCESS',
+                    payload: {
+                        results: data.results,
+                        total: data.total,
+                        hasMore: data.hasMore,
+                        nextCursor: data.after,
+                    },
+                }
+                : {
+                    type: 'FETCH_SUCCESS',
+                    payload: {
+                        results: data.results,
+                        total: data.total,
+                        hasMore: data.hasMore,
+                        nextCursor: data.after,
+                        currentCursor: state.currentCursor,
+                    },
+                }),
+            onError: (error, { isRefetch }) => dispatch({
+                type: isRefetch ? 'REFETCH_ERROR' : 'FETCH_ERROR',
+                payload: error,
+            }),
+        },
+        deps: [stableConfig, stableOptions, state.currentCursor],
+        defaultErrorMessage: 'Failed to fetch CRM search results',
+    });
+    const paginationFlags = calculatePaginationFlags(state.currentPage, state.hasMore);
+    return {
+        results: state.results,
+        total: state.total,
+        error: state.error,
+        isLoading: state.isLoading,
+        isRefetching: state.isRefetching,
+        refetch,
+        pagination: {
+            hasNextPage: paginationFlags.hasNextPage,
+            hasPreviousPage: paginationFlags.hasPreviousPage,
+            currentPage: state.currentPage,
+            pageSize,
+            nextPage,
+            previousPage,
+            reset,
+        },
+    };
+}

package/dist/experimental/hooks/utils/fetchCrmSearch.d.ts

@@ -0,0 +1,6 @@
+import type { CrmSearchResponse, FetchCrmSearchRequest, FetchHookOptions } from '../../../shared/types/hooks.ts';
+export interface FetchCrmSearchResult {
+    data: CrmSearchResponse;
+    cleanup: () => void;
+}
+export declare const fetchCrmSearch: (request: FetchCrmSearchRequest, options?: FetchHookOptions) => Promise<FetchCrmSearchResult>;