@hubspot/ui-extensions 0.13.0 → 0.13.1

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

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/experimental/hooks/utils/fetchCrmSearch.spec.js

@@ -0,0 +1,217 @@
+import { vi } from 'vitest';
+import { fetchCrmSearch } from "../../../../experimental/hooks/utils/fetchCrmSearch.js";
+const mockFetchCrmSearch = vi.fn();
+// Mock the global self object to match the hsWorkerAPI shape
+Object.defineProperty(global, 'self', {
+    value: {
+        __HUBSPOT_EXTENSION_WORKER__: true,
+        hsWorkerAPI: {
+            fetchCrmSearch: mockFetchCrmSearch,
+        },
+    },
+    writable: true,
+});
+describe('fetchCrmSearch', () => {
+    const createMockResponse = (data, overrides = {}) => ({
+        ok: true,
+        json: vi.fn().mockResolvedValue({ data, cleanup: vi.fn() }),
+        ...overrides,
+    });
+    const createBasicRequest = (overrides = {}) => ({
+        objectType: '0-1',
+        properties: ['firstname', 'lastname'],
+        ...overrides,
+    });
+    const createValidResponseData = (overrides = {}) => ({
+        results: [
+            {
+                objectId: 1001,
+                properties: { firstname: 'John', lastname: 'Doe' },
+            },
+        ],
+        total: 1,
+        hasMore: false,
+        ...overrides,
+    });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('basic functionality', () => {
+        it('should successfully fetch CRM search results', async () => {
+            const data = createValidResponseData();
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(data));
+            const request = createBasicRequest();
+            const result = await fetchCrmSearch(request);
+            expect(result).toHaveProperty('data');
+            expect(result).toHaveProperty('cleanup');
+            expect(typeof result.cleanup).toBe('function');
+            expect(result.data).toEqual(data);
+        });
+        it('should return a Promise', () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(createValidResponseData()));
+            const result = fetchCrmSearch(createBasicRequest());
+            expect(result).toBeInstanceOf(Promise);
+        });
+        it('should support all request fields (query, filterGroups, sorts, pageSize, after)', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(createValidResponseData({ hasMore: true, after: 'cursor-2' })));
+            const request = {
+                objectType: '0-1',
+                properties: ['firstname'],
+                query: 'john',
+                filterGroups: [
+                    {
+                        filters: [
+                            { propertyName: 'lifecyclestage', operator: 'EQ', value: 'lead' },
+                        ],
+                    },
+                ],
+                sorts: [
+                    { propertyName: 'createdate', direction: 'DESCENDING' },
+                ],
+                pageSize: 25,
+                after: 'cursor-1',
+            };
+            await fetchCrmSearch(request);
+            expect(mockFetchCrmSearch).toHaveBeenCalledWith(request, undefined);
+        });
+    });
+    describe('error handling', () => {
+        it('should throw an error when fetch fails', async () => {
+            mockFetchCrmSearch.mockRejectedValueOnce(new Error('Network error'));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Network error');
+        });
+        it('should handle unknown errors with a default message', async () => {
+            mockFetchCrmSearch.mockRejectedValueOnce('Unknown error');
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Failed to fetch CRM search results: Unknown error');
+        });
+        it('should throw when server returns an error field', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce({
+                ok: true,
+                json: vi.fn().mockResolvedValue({
+                    error: 'Permission denied',
+                    cleanup: vi.fn(),
+                }),
+            });
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Permission denied');
+        });
+    });
+    describe('response validation', () => {
+        it('should throw error when results field is missing', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({ total: 0, hasMore: false }) // missing results
+            );
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when results is not an array', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({
+                results: 'not an array',
+                total: 0,
+                hasMore: false,
+            }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when total is not a number', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({ results: [], total: 'zero', hasMore: false }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when hasMore is not a boolean', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({ results: [], total: 0, hasMore: 'yes' }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when data is null', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(null));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when a result is missing objectId', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({
+                results: [{ properties: {} }],
+                total: 1,
+                hasMore: false,
+            }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when a result objectId is not a number', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({
+                results: [{ objectId: '1001', properties: {} }],
+                total: 1,
+                hasMore: false,
+            }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+        it('should throw error when a result properties field is not an object', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse({
+                results: [{ objectId: 1, properties: null }],
+                total: 1,
+                hasMore: false,
+            }));
+            await expect(fetchCrmSearch(createBasicRequest())).rejects.toThrow('Invalid response format');
+        });
+    });
+    describe('API integration', () => {
+        it('should call hsWorkerAPI.fetchCrmSearch with correct parameters and no options', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(createValidResponseData()));
+            const request = createBasicRequest({ pageSize: 50 });
+            await fetchCrmSearch(request);
+            expect(mockFetchCrmSearch).toHaveBeenCalledWith(request, undefined);
+        });
+        it('should return the cleanup function provided by the API response', async () => {
+            const mockCleanup = vi.fn();
+            mockFetchCrmSearch.mockResolvedValueOnce({
+                ok: true,
+                json: vi.fn().mockResolvedValue({
+                    data: createValidResponseData(),
+                    cleanup: mockCleanup,
+                }),
+            });
+            const result = await fetchCrmSearch(createBasicRequest());
+            expect(result.cleanup).toBe(mockCleanup);
+            result.cleanup();
+            expect(mockCleanup).toHaveBeenCalledTimes(1);
+        });
+        it('should provide a default cleanup function when none is provided', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce({
+                ok: true,
+                json: vi.fn().mockResolvedValue({ data: createValidResponseData() }),
+            });
+            const result = await fetchCrmSearch(createBasicRequest());
+            expect(typeof result.cleanup).toBe('function');
+            expect(() => result.cleanup()).not.toThrow();
+        });
+    });
+    describe('options handling', () => {
+        it('should pass formatting options to the underlying fetch function', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(createValidResponseData()));
+            const options = {
+                propertiesToFormat: ['firstname'],
+                formattingOptions: {
+                    date: { format: 'MM/dd/yyyy' },
+                    currency: { addSymbol: true },
+                },
+            };
+            await fetchCrmSearch(createBasicRequest(), options);
+            expect(mockFetchCrmSearch).toHaveBeenCalledWith(createBasicRequest(), options);
+        });
+        it('should handle propertiesToFormat set to "all"', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse(createValidResponseData()));
+            const options = {
+                propertiesToFormat: 'all',
+                formattingOptions: { dateTime: { relative: true } },
+            };
+            await fetchCrmSearch(createBasicRequest(), options);
+            expect(mockFetchCrmSearch).toHaveBeenCalledWith(createBasicRequest(), options);
+        });
+        it('should preserve error handling with formatting options', async () => {
+            mockFetchCrmSearch.mockRejectedValueOnce(new Error('Network error'));
+            const options = {
+                propertiesToFormat: ['firstname'],
+                formattingOptions: { date: { format: 'MM/dd/yyyy' } },
+            };
+            await expect(fetchCrmSearch(createBasicRequest(), options)).rejects.toThrow('Network error');
+            expect(mockFetchCrmSearch).toHaveBeenCalledWith(createBasicRequest(), options);
+        });
+        it('should preserve response validation with formatting options', async () => {
+            mockFetchCrmSearch.mockResolvedValueOnce(createMockResponse('Invalid response') // data should be an object
+            );
+            await expect(fetchCrmSearch(createBasicRequest(), { propertiesToFormat: 'all' })).rejects.toThrow('Invalid response format');
+        });
+    });
+});

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

@@ -1,4 +1,4 @@
-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 type UseAssociationsOptions = {

package/dist/crm/hooks/useAssociations.js

@@ -1,16 +1,15 @@
-import { useCallback, useMemo, useReducer } from 'react';
+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,
@@ -72,6 +71,7 @@ function associationsReducer(state, action) {
                 ...state,
                 currentPage: 1,
                 results: [],
+                isLoading: true,
                 hasMore: false,
                 error: null,
                 currentOffset: undefined,
@@ -109,7 +109,16 @@ 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());
+    /**
+     * 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);
     // Pagination actions
@@ -191,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/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>;

package/dist/experimental/hooks/utils/fetchCrmSearch.js

@@ -0,0 +1,39 @@
+import { getWorkerGlobals } from "../../../internal/global-utils.js";
+function isCrmSearchResponse(data) {
+    const d = data;
+    if (d === null ||
+        typeof d !== 'object' ||
+        !Array.isArray(d.results) ||
+        typeof d.total !== 'number' ||
+        typeof d.hasMore !== 'boolean') {
+        return false;
+    }
+    return d.results.every((result) => result !== null &&
+        typeof result === 'object' &&
+        typeof result.objectId === 'number' &&
+        result.properties !== null &&
+        typeof result.properties === 'object');
+}
+export const fetchCrmSearch = async (request, options) => {
+    let response;
+    let result;
+    try {
+        response = await getWorkerGlobals().hsWorkerAPI.fetchCrmSearch(request, options);
+        result = await response.json();
+    }
+    catch (error) {
+        throw error instanceof Error
+            ? error
+            : new Error('Failed to fetch CRM search results: Unknown error');
+    }
+    if (result.error) {
+        throw new Error(result.error);
+    }
+    if (!isCrmSearchResponse(result.data)) {
+        throw new Error('Invalid response format');
+    }
+    return {
+        data: result.data,
+        cleanup: result.cleanup || (() => { }),
+    };
+};

package/dist/experimental/index.d.ts

@@ -1,4 +1,5 @@
 export { useCrmProperties } from '../crm/hooks/useCrmProperties.ts';
 export { useAssociations } from '../crm/hooks/useAssociations.ts';
+export { useCrmSearch } from './hooks/useCrmSearch.ts';
 export { Iframe, MediaObject, Stack2, Center, GridItem, Grid, SettingsView, ExpandableText, Popover, FileInput, } from '../shared/remoteComponents.tsx';
 export type * from '../shared/types/experimental.ts';

package/dist/experimental/index.js

@@ -1,3 +1,4 @@
 export { useCrmProperties } from "../crm/hooks/useCrmProperties.js";
 export { useAssociations } from "../crm/hooks/useAssociations.js";
+export { useCrmSearch } from "./hooks/useCrmSearch.js";
 export { Iframe, MediaObject, Stack2, Center, GridItem, Grid, SettingsView, ExpandableText, Popover, FileInput, } from "../shared/remoteComponents.js";

package/dist/shared/types/components/table.d.ts

@@ -70,6 +70,14 @@ export interface SortedTableHeaderProps extends BaseTableHeaderProps {
  * @category Component Props
  */
 export type TableHeaderProps = SortedTableHeaderProps | UnSortedTableHeaderProps;
+/**
+ * Controls row height and vertical padding for every cell in the table.
+ *
+ * - `'default'`: generous row height and padding around content.
+ * - `'condensed'`: moderate row height and padding around content.
+ * - `'compact'`: no min row height, minimal padding. Rows collapse to content height.
+ */
+export type TableDensity = 'default' | 'condensed' | 'compact';
 interface BaseTableProps extends BaseComponentProps {
     /**
      * When set to `false`, the table will not include borders.
@@ -83,6 +91,14 @@ interface BaseTableProps extends BaseComponentProps {
      * @defaultValue `false`
      */
     flush?: boolean;
+    /**
+     * Sets row height and vertical padding for all header, body, and footer cells.
+     * Use `'condensed'` for denser data views and `'compact'` when rows should be
+     * sized only to their content.
+     *
+     * @defaultValue `'default'`
+     */
+    density?: TableDensity;
     /**
      * Sets the content that will render inside the component. This prop is passed implicitly by providing sub-components. The children should be one of Table's subcomponents.
      */

package/dist/shared/types/context.d.ts

@@ -18,6 +18,7 @@ export interface UserContext {
     roles: string[];
     teams: Team[];
     locale?: string;
+    language?: string;
     permissions: Permission[];
 }
 /** @ignore */

package/dist/shared/types/experimental.d.ts

@@ -1,6 +1,7 @@
 import type { ReactNode } from 'react';
 import type { ReactionsHandler } from './reactions.ts';
 import type { AllDistances, BaseComponentProps, ExtensionEvent } from './shared.ts';
+export type { CrmSearchFilter, CrmSearchFilterGroup, CrmSearchResponse, CrmSearchResultItem, CrmSearchSort, FetchCrmSearchRequest, UseCrmSearchOptions, UseCrmSearchResult, FormattingOptions, } from './hooks.ts';
 /**
  * @ignore
  * @experimental do not use in production
@@ -233,4 +234,3 @@ export interface BaseInputProps<T = string, V = string> {
      */
     onFocus?: (value: V) => void;
 }
-export {};