@antscorp/antsomi-ui 2.0.103 → 2.0.105

package/es/components/organism/SQLGeneration/selectors.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import { cloneDeep, last } from 'lodash';
+// Careful with selectors that return objects or arrays
+// They are cached by reference, so if you mutate the returned object or array, you'll mutate the cache
+// If you need to mutate the returned object or array, return a new object or array
+// Ex: export const selectPreviousCurrentResult = createSelector(
+//   [selectAllPreviousResults],
+//   previousResults => previousResults.pop(),
+// );
+export const selectTableSources = createSelector([(state) => state.tableSources], tableSources => tableSources);
+export const selectSelctedTableSources = createSelector([selectTableSources], tableSources => tableSources.filter(t => t.selected));
+export const selectIsEditTableSourcesOpen = (state) => state.isEditTableSourcesOpen;
+export const selectIsEditingPrompt = (state) => state.isEditingPrompt;
+export const selectIsOpen = (state) => state.isOpen;
+export const selectPrompt = (state) => state.prompt;
+// Error selectors
+export const selectError = (state) => state.error;
+export const selectGenerateSQLError = (state) => state.generateSQLError;
+export const selectRefineSQLError = (state) => state.refineSQLError;
+export const selectQuerySummaryError = (state) => state.querySummaryError;
+export const selectHasAnyError = createSelector([selectGenerateSQLError, selectRefineSQLError, selectQuerySummaryError], (generateError, refineError, summaryError) => !!(generateError || refineError || summaryError));
+export const selectIsLoading = (state) => state.isLoading;
+export const selectCurrentResultKey = (state) => state.currentResultKey;
+export const selectResults = (state) => state.results;
+export const selectResultsByKey = (state) => state.results.byKey;
+export const selectResultsAllKeys = (state) => state.results.allKeys;
+export const selectCurrentResult = createSelector([selectResultsByKey, selectCurrentResultKey], (resultsByKey, currentResultKey) => currentResultKey ? resultsByKey[currentResultKey] : undefined);
+export const selectCurrentResultIndex = createSelector([selectCurrentResultKey, selectResultsAllKeys], (currentResultKey, allKeys) => allKeys.findIndex(i => i === currentResultKey));
+export const selectIsEmptyResult = createSelector([selectResultsAllKeys], allKeys => allKeys.length === 0);
+export const selectIsLastResult = createSelector([selectCurrentResultIndex, selectResultsAllKeys], (currentResultIndex, allKeys) => currentResultIndex === allKeys.length - 1);
+export const selectAllResults = createSelector([selectResultsByKey], resultsByKey => Object.values(resultsByKey));
+export const selectAllPreviousResultKeys = createSelector([selectCurrentResultIndex, selectResultsAllKeys], (currentResultIndex, allKeys) => allKeys.slice(0, currentResultIndex));
+export const selectAllPreviousResults = createSelector([selectAllPreviousResultKeys, selectResultsByKey], (allKeys, resultsByKey) => allKeys.map(key => cloneDeep(resultsByKey[key])));
+export const selectAllNextResultKeys = createSelector([selectCurrentResultIndex, selectResultsAllKeys], (currentResultIndex, allKeys) => allKeys.slice(currentResultIndex + 1));
+export const selectAllNextResults = createSelector([selectAllNextResultKeys, selectResultsByKey], (allKeys, resultsByKey) => allKeys.map(key => resultsByKey[key]));
+export const selectTotalResults = createSelector([selectResultsAllKeys], allKeys => allKeys.length);
+export const selectHasResult = createSelector([selectResultsAllKeys, selectCurrentResult], (allKeys, currentResult) => allKeys.length > 0 && !!currentResult);
+export const selectCurrentResultSummary = createSelector([selectCurrentResult], currentResult => currentResult?.summary);
+export const selectIsSummaryLoading = createSelector([(state) => state.isSummaryLoading], isSummaryLoading => isSummaryLoading);
+export const selectRefinePrompt = createSelector([(state) => state.refinePrompt], refinePrompt => refinePrompt);
+export const selectIsRefining = createSelector([(state) => state.isRefining], isRefining => isRefining);
+export const selectResultSettings = createSelector([(state) => state.results.byKeySettings], byKeySettings => byKeySettings);
+export const selectCurrentResultSettings = createSelector([selectResultSettings, selectCurrentResultKey], (byKeySettings, currentResultKey) => currentResultKey ? byKeySettings[currentResultKey] : undefined);
+export const selectCurrentResultShowDiff = createSelector([selectCurrentResultSettings], currentResultSettings => currentResultSettings?.showDiff);
+export const selectPreviousCurrentResult = createSelector([selectAllPreviousResults], previousResults => last(previousResults));
+export const selectCurrentOperationError = createSelector([
+    selectIsLoading,
+    selectIsRefining,
+    selectIsSummaryLoading,
+    selectGenerateSQLError,
+    selectRefineSQLError,
+    selectQuerySummaryError,
+], (isLoading, isRefining, isSummaryLoading, generateError, refineError, summaryError) => {
+    if (isLoading)
+        return generateError;
+    if (isRefining)
+        return refineError;
+    if (isSummaryLoading)
+        return summaryError;
+    return generateError || refineError || summaryError;
+});

package/es/components/organism/SQLGeneration/store/index.d.ts

@@ -0,0 +1,2 @@
+export { type SQLGenerationStoreApi } from './store';
+export { SQLGenerationProvider, type SQLGenerationProviderProps, useSQLGenerationStore, } from './provider';

package/es/components/organism/SQLGeneration/store/index.js

@@ -0,0 +1 @@
+export { SQLGenerationProvider, useSQLGenerationStore, } from './provider';

package/es/components/organism/SQLGeneration/store/provider.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import { type SQLGenerationStore, SQLGenerationStoreInitialProps } from './types';
+export interface SQLGenerationProviderProps extends SQLGenerationStoreInitialProps {
+    children: ReactNode;
+}
+export declare const SQLGenerationProvider: ({ children, ...props }: SQLGenerationProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useSQLGenerationStore: <T>(selector: (store: SQLGenerationStore) => T, equalityFn?: (a: T, b: T) => boolean) => T;

package/es/components/organism/SQLGeneration/store/provider.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef, useContext, useEffect } from 'react';
+import { useStoreWithEqualityFn } from 'zustand/traditional';
+import { shallow } from 'zustand/shallow';
+import { SQLGenerationContext, createSQLGenerationStore } from './store';
+export const SQLGenerationProvider = ({ children, ...props }) => {
+    const { onGenerateSQL, onInsertSQL, onQuerySummary, onRefineSQL, env = 'production' } = props;
+    const storeRef = useRef();
+    if (!storeRef.current) {
+        storeRef.current = createSQLGenerationStore({ ...props, env });
+    }
+    useEffect(() => {
+        if (onGenerateSQL) {
+            storeRef.current?.setState({ onGenerateSQL });
+        }
+    }, [onGenerateSQL]);
+    useEffect(() => {
+        if (onInsertSQL) {
+            storeRef.current?.setState({ onInsertSQL });
+        }
+    }, [onInsertSQL]);
+    useEffect(() => {
+        if (onQuerySummary) {
+            storeRef.current?.setState({ onQuerySummary });
+        }
+    }, [onQuerySummary]);
+    useEffect(() => {
+        if (onRefineSQL) {
+            storeRef.current?.setState({ onRefineSQL });
+        }
+    }, [onRefineSQL]);
+    return (_jsx(SQLGenerationContext.Provider, { value: storeRef.current, children: children }));
+};
+export const useSQLGenerationStore = (selector, equalityFn) => {
+    const context = useContext(SQLGenerationContext);
+    if (!context) {
+        throw new Error('useSQLGenerationStore must be used within SQLGenerationStoreProvider');
+    }
+    return useStoreWithEqualityFn(context, selector, equalityFn || shallow);
+};

package/es/components/organism/SQLGeneration/store/store.d.ts

@@ -0,0 +1,383 @@
+/// <reference types="react" />
+import { SQLGenerationState, SQLGenerationStore, SQLGenerationStoreInitialProps } from './types';
+export declare const createSQLGenerationStore: (initProps?: SQLGenerationStoreInitialProps) => Omit<Omit<import("zustand").StoreApi<SQLGenerationStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: SQLGenerationStore | Partial<SQLGenerationStore> | ((state: SQLGenerationStore) => SQLGenerationStore | Partial<SQLGenerationStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: SQLGenerationStore | Partial<SQLGenerationStore> | ((state: {
+        abortControllers: {
+            generateSQL?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+            querySummary?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+            refineSQL?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+        };
+        isOpen: boolean;
+        isLoading: boolean;
+        isRefining: boolean;
+        isSummaryLoading: boolean;
+        isEditTableSourcesOpen: boolean;
+        isEditingPrompt: boolean;
+        currentResultKey: string | null;
+        error: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        generateSQLError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        refineSQLError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        querySummaryError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        prompt: string;
+        refinePrompt: string;
+        tableSources: {
+            id: string;
+            name: string;
+            dataset: string;
+            project: string;
+            selected: boolean;
+        }[];
+        searchQuery: string;
+        results: {
+            byKey: {
+                [x: string]: {
+                    key: string;
+                    prompt: string;
+                    sqlSuggestion: string;
+                    summary?: string | undefined;
+                    refinePrompt?: string | undefined;
+                    explanation?: string | undefined;
+                    processedDataSize?: string | undefined;
+                    estimatedCost?: string | undefined;
+                    queryComplexity?: "medium" | "simple" | "complex" | undefined;
+                };
+            };
+            byKeySettings: {
+                [x: string]: {
+                    showDiff: boolean;
+                };
+            };
+            allKeys: string[];
+        };
+        onGenerateSQL?: ((prompt: string, context: import("../types").SQLGenerationContext, options: {
+            signal: AbortSignal;
+        }) => Promise<import("..").SQLGenerationResult>) | undefined;
+        onRefineSQL?: ((refinePrompt: string, context: import("../types").SQLGenerationContext, options: {
+            signal: AbortSignal;
+        }) => Promise<import("..").SQLGenerationResult>) | undefined;
+        onInsertSQL?: ((sql: string) => void) | undefined;
+        onQuerySummary?: ((sql: string, options: {
+            signal: AbortSignal;
+        }) => Promise<string>) | undefined;
+        onOpenChange?: ((open: boolean) => void) | undefined;
+        setState: (update: Partial<SQLGenerationState>) => void;
+        reset: () => void;
+        setIsOpen: (isOpen: boolean) => void;
+        setIsLoading: (isLoading: boolean) => void;
+        setIsSummaryLoading: (isLoading: boolean) => void;
+        setIsEditTableSourcesOpen: (isOpen: boolean) => void;
+        setIsEditingPrompt: (isEditing: boolean) => void;
+        setCurrentResultKey: (key: string) => void;
+        setPrompt: (prompt: string) => void;
+        setResults: (results: import("./types").SQLResults) => void;
+        setTableSources: (sources: import("..").TableSource[]) => void;
+        setSearchQuery: (query: string) => void;
+        setRefinePrompt: (prompt: string) => void;
+        setIsRefining: (isRefining: boolean) => void;
+        setCurrentResultSettings: (updateFn: (draft: {
+            showDiff: boolean;
+        }) => void) => void;
+        setError: (error: import("./types").SQLGenerationError | null) => void;
+        setGenerateSQLError: (error: import("./types").SQLGenerationError | null) => void;
+        setRefineSQLError: (error: import("./types").SQLGenerationError | null) => void;
+        setQuerySummaryError: (error: import("./types").SQLGenerationError | null) => void;
+        clearErrors: () => void;
+        clearError: (operation: "generateSQL" | "refineSQL" | "querySummary") => void;
+        generateSQL: () => Promise<void>;
+        insertSQL: () => void;
+        querySummary: () => Promise<void>;
+        refineSQL: () => Promise<void>;
+        abortGenerateSQL: () => void;
+        abortQuerySummary: () => void;
+        abortRefineSQL: () => void;
+        retryGenerateSQL: () => Promise<void>;
+        retryRefineSQL: () => Promise<void>;
+        retryQuerySummary: () => Promise<void>;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+};
+export type SQLGenerationStoreApi = ReturnType<typeof createSQLGenerationStore>;
+export declare const SQLGenerationContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<SQLGenerationStore>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: SQLGenerationStore | Partial<SQLGenerationStore> | ((state: SQLGenerationStore) => SQLGenerationStore | Partial<SQLGenerationStore>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: SQLGenerationStore | Partial<SQLGenerationStore> | ((state: {
+        abortControllers: {
+            generateSQL?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+            querySummary?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+            refineSQL?: {
+                signal: {
+                    aborted: boolean;
+                    onabort: ((this: AbortSignal, ev: Event) => any) | null;
+                    reason: any;
+                    throwIfAborted: {
+                        (): void;
+                        (): void;
+                    };
+                    addEventListener: {
+                        <K extends "abort">(type: K, listener: (this: AbortSignal, ev: AbortSignalEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+                    };
+                    removeEventListener: {
+                        <K_1 extends "abort">(type: K_1, listener: (this: AbortSignal, ev: AbortSignalEventMap[K_1]) => any, options?: boolean | EventListenerOptions | undefined): void;
+                        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+                    };
+                    dispatchEvent: (event: Event) => boolean;
+                };
+                abort: {
+                    (reason?: any): void;
+                    (reason?: any): void;
+                };
+            } | undefined;
+        };
+        isOpen: boolean;
+        isLoading: boolean;
+        isRefining: boolean;
+        isSummaryLoading: boolean;
+        isEditTableSourcesOpen: boolean;
+        isEditingPrompt: boolean;
+        currentResultKey: string | null;
+        error: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        generateSQLError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        refineSQLError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        querySummaryError: {
+            message: string;
+            code?: string | undefined;
+            timestamp: number;
+            operation: "generateSQL" | "refineSQL" | "querySummary";
+        } | null;
+        prompt: string;
+        refinePrompt: string;
+        tableSources: {
+            id: string;
+            name: string;
+            dataset: string;
+            project: string;
+            selected: boolean;
+        }[];
+        searchQuery: string;
+        results: {
+            byKey: {
+                [x: string]: {
+                    key: string;
+                    prompt: string;
+                    sqlSuggestion: string;
+                    summary?: string | undefined;
+                    refinePrompt?: string | undefined;
+                    explanation?: string | undefined;
+                    processedDataSize?: string | undefined;
+                    estimatedCost?: string | undefined;
+                    queryComplexity?: "medium" | "simple" | "complex" | undefined;
+                };
+            };
+            byKeySettings: {
+                [x: string]: {
+                    showDiff: boolean;
+                };
+            };
+            allKeys: string[];
+        };
+        onGenerateSQL?: ((prompt: string, context: import("../types").SQLGenerationContext, options: {
+            signal: AbortSignal;
+        }) => Promise<import("..").SQLGenerationResult>) | undefined;
+        onRefineSQL?: ((refinePrompt: string, context: import("../types").SQLGenerationContext, options: {
+            signal: AbortSignal;
+        }) => Promise<import("..").SQLGenerationResult>) | undefined;
+        onInsertSQL?: ((sql: string) => void) | undefined;
+        onQuerySummary?: ((sql: string, options: {
+            signal: AbortSignal;
+        }) => Promise<string>) | undefined;
+        onOpenChange?: ((open: boolean) => void) | undefined;
+        setState: (update: Partial<SQLGenerationState>) => void;
+        reset: () => void;
+        setIsOpen: (isOpen: boolean) => void;
+        setIsLoading: (isLoading: boolean) => void;
+        setIsSummaryLoading: (isLoading: boolean) => void;
+        setIsEditTableSourcesOpen: (isOpen: boolean) => void;
+        setIsEditingPrompt: (isEditing: boolean) => void;
+        setCurrentResultKey: (key: string) => void;
+        setPrompt: (prompt: string) => void;
+        setResults: (results: import("./types").SQLResults) => void;
+        setTableSources: (sources: import("..").TableSource[]) => void;
+        setSearchQuery: (query: string) => void;
+        setRefinePrompt: (prompt: string) => void;
+        setIsRefining: (isRefining: boolean) => void;
+        setCurrentResultSettings: (updateFn: (draft: {
+            showDiff: boolean;
+        }) => void) => void;
+        setError: (error: import("./types").SQLGenerationError | null) => void;
+        setGenerateSQLError: (error: import("./types").SQLGenerationError | null) => void;
+        setRefineSQLError: (error: import("./types").SQLGenerationError | null) => void;
+        setQuerySummaryError: (error: import("./types").SQLGenerationError | null) => void;
+        clearErrors: () => void;
+        clearError: (operation: "generateSQL" | "refineSQL" | "querySummary") => void;
+        generateSQL: () => Promise<void>;
+        insertSQL: () => void;
+        querySummary: () => Promise<void>;
+        refineSQL: () => Promise<void>;
+        abortGenerateSQL: () => void;
+        abortQuerySummary: () => void;
+        abortRefineSQL: () => void;
+        retryGenerateSQL: () => Promise<void>;
+        retryRefineSQL: () => Promise<void>;
+        retryQuerySummary: () => Promise<void>;
+    }) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: string;
+    } | undefined): void;
+}) | undefined>;