@tsdevstack/react-bot-detection 0.1.4

package/dist/components/bot-protected-form.test.js

@@ -0,0 +1,366 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { afterEach, beforeEach, describe, expect, it, rs } from "@rstest/core";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { BotProtectedForm } from "./bot-protected-form.js";
+import { useBotDetection } from "../hooks/use-bot-detection.js";
+import { useHoneypot } from "../hooks/use-honeypot.js";
+afterEach(()=>{
+    cleanup();
+});
+rs.mock('../hooks/use-bot-detection', ()=>({
+        useBotDetection: rs.fn(()=>({
+                botScore: 0,
+                detectionReasons: [],
+                isBot: false,
+                handleFieldFocus: rs.fn(),
+                handleFormSubmit: rs.fn(()=>({
+                        score: 0,
+                        reasons: []
+                    })),
+                stats: {
+                    mouseMovements: 10,
+                    typingEvents: 20,
+                    focusEvents: 5,
+                    timeSpent: 5000
+                }
+            }))
+    }));
+rs.mock('../hooks/use-honeypot', ()=>({
+        useHoneypot: rs.fn(()=>({
+                isBotDetected: false,
+                HoneypotComponent: ()=>/*#__PURE__*/ jsx("div", {
+                        "data-testid": "honeypot"
+                    })
+            }))
+    }));
+const mockUseBotDetection = useBotDetection;
+const mockUseHoneypot = useHoneypot;
+describe('BotProtectedForm', ()=>{
+    const mockOnSubmit = rs.fn();
+    beforeEach(()=>{
+        rs.clearAllMocks();
+        mockOnSubmit.mockResolvedValue(void 0);
+        mockUseBotDetection.mockReturnValue({
+            botScore: 0,
+            detectionReasons: [],
+            isBot: false,
+            handleFieldFocus: rs.fn(),
+            handleFormSubmit: rs.fn(()=>({
+                    score: 0,
+                    reasons: []
+                })),
+            stats: {
+                mouseMovements: 10,
+                typingEvents: 20,
+                focusEvents: 5,
+                timeSpent: 5000
+            }
+        });
+        mockUseHoneypot.mockReturnValue({
+            isBotDetected: false,
+            HoneypotComponent: ()=>/*#__PURE__*/ jsx("div", {
+                    "data-testid": "honeypot"
+                })
+        });
+    });
+    describe('Rendering', ()=>{
+        it('should render children and submit button', ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email",
+                    "data-testid": "email"
+                })
+            }));
+            expect(screen.getByTestId('email')).not.toBeNull();
+            expect(screen.getByRole('button', {
+                name: 'Submit'
+            })).not.toBeNull();
+        });
+        it('should render honeypot component', ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            expect(screen.getByTestId('honeypot')).not.toBeNull();
+        });
+        it('should use custom submit button text', ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                submitButtonText: "Send",
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            expect(screen.getByRole('button', {
+                name: 'Send'
+            })).not.toBeNull();
+        });
+        it('should apply className to form', ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                className: "my-form-class",
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            const form = screen.getByRole('button').closest('form');
+            expect(form?.classList.contains('my-form-class')).toBe(true);
+        });
+    });
+    describe('Custom Button Component', ()=>{
+        it('should use custom ButtonComponent', ()=>{
+            const CustomButton = ({ children, disabled, type })=>/*#__PURE__*/ jsxs("button", {
+                    type: type,
+                    disabled: disabled,
+                    "data-testid": "custom-button",
+                    children: [
+                        "Custom: ",
+                        children
+                    ]
+                });
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                ButtonComponent: CustomButton,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            expect(screen.getByTestId('custom-button')).not.toBeNull();
+            expect(screen.getByText('Custom: Submit')).not.toBeNull();
+        });
+    });
+    describe('Form Submission', ()=>{
+        it('should call onSubmit with FormData and bot detection result', async ()=>{
+            const user = user_event.setup();
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email",
+                    defaultValue: "test@example.com"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            await waitFor(()=>{
+                expect(mockOnSubmit).toHaveBeenCalledTimes(1);
+            });
+            const [formData, botResult] = mockOnSubmit.mock.calls[0];
+            expect(formData).toBeInstanceOf(FormData);
+            expect(formData.get('email')).toBe('test@example.com');
+            expect(botResult).toMatchObject({
+                score: 0,
+                reasons: [],
+                isBot: false,
+                honeypotTriggered: false
+            });
+        });
+        it('should show loading text while submitting', async ()=>{
+            const user = user_event.setup();
+            let resolveSubmit;
+            mockOnSubmit.mockImplementation(()=>new Promise((resolve)=>{
+                    resolveSubmit = resolve;
+                }));
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                submitButtonText: "Submit",
+                loadingButtonText: "Processing...",
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            await waitFor(()=>{
+                expect(screen.getByRole('button', {
+                    name: 'Processing...'
+                })).not.toBeNull();
+            });
+            resolveSubmit();
+            await waitFor(()=>{
+                expect(screen.getByRole('button', {
+                    name: 'Submit'
+                })).not.toBeNull();
+            });
+        });
+    });
+    describe('Bot Detection Blocking', ()=>{
+        it('should not call onSubmit when behavioral bot detection triggers', async ()=>{
+            const user = user_event.setup();
+            mockUseBotDetection.mockReturnValue({
+                botScore: 100,
+                detectionReasons: [
+                    'Suspicious behavior'
+                ],
+                isBot: true,
+                handleFieldFocus: rs.fn(),
+                handleFormSubmit: rs.fn(()=>({
+                        score: 100,
+                        reasons: [
+                            'Suspicious behavior'
+                        ]
+                    })),
+                stats: {
+                    mouseMovements: 0,
+                    typingEvents: 0,
+                    focusEvents: 0,
+                    timeSpent: 100
+                }
+            });
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            expect(mockOnSubmit).not.toHaveBeenCalled();
+        });
+        it('should not call onSubmit when honeypot is triggered', async ()=>{
+            const user = user_event.setup();
+            mockUseHoneypot.mockReturnValue({
+                isBotDetected: true,
+                HoneypotComponent: ()=>/*#__PURE__*/ jsx("div", {
+                        "data-testid": "honeypot"
+                    })
+            });
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            expect(mockOnSubmit).not.toHaveBeenCalled();
+        });
+        it('should not disable submit button based on stale bot detection state', ()=>{
+            mockUseBotDetection.mockReturnValue({
+                botScore: 100,
+                detectionReasons: [
+                    'Suspicious behavior'
+                ],
+                isBot: true,
+                handleFieldFocus: rs.fn(),
+                handleFormSubmit: rs.fn(),
+                stats: {
+                    mouseMovements: 0,
+                    typingEvents: 0,
+                    focusEvents: 0,
+                    timeSpent: 100
+                }
+            });
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            const button = screen.getByRole('button', {
+                name: 'Submit'
+            });
+            expect(button.disabled).toBe(false);
+        });
+    });
+    describe('onBotDetected callback', ()=>{
+        it('should call onBotDetected when form detects a bot during submission', async ()=>{
+            const user = user_event.setup();
+            const mockOnBotDetected = rs.fn();
+            mockUseBotDetection.mockReturnValue({
+                botScore: 0,
+                detectionReasons: [],
+                isBot: false,
+                handleFieldFocus: rs.fn(),
+                handleFormSubmit: rs.fn(()=>({
+                        score: 80,
+                        reasons: [
+                            'Too fast submission'
+                        ]
+                    })),
+                stats: {
+                    mouseMovements: 0,
+                    typingEvents: 0,
+                    focusEvents: 0,
+                    timeSpent: 100
+                }
+            });
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                onBotDetected: mockOnBotDetected,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            await waitFor(()=>{
+                expect(mockOnBotDetected).toHaveBeenCalledWith(expect.objectContaining({
+                    score: 80,
+                    isBot: true,
+                    reasons: expect.arrayContaining([
+                        'Too fast submission'
+                    ])
+                }));
+            });
+            expect(mockOnSubmit).not.toHaveBeenCalled();
+        });
+    });
+    describe('Debug Panel', ()=>{
+        it('should not render debug panel by default', ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            expect(screen.queryByText('Bot Detection Debug')).toBeNull();
+        });
+        it('should render debug panel when showDebugPanel is true', async ()=>{
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                showDebugPanel: true,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await waitFor(()=>{
+                expect(screen.getByText('Bot Detection Debug')).not.toBeNull();
+            });
+        });
+    });
+    describe('Error Handling', ()=>{
+        it('should handle submission errors gracefully', async ()=>{
+            const user = user_event.setup();
+            const consoleError = rs.spyOn(console, 'error').mockImplementation(()=>{});
+            mockOnSubmit.mockRejectedValue(new Error('Network error'));
+            render(/*#__PURE__*/ jsx(BotProtectedForm, {
+                onSubmit: mockOnSubmit,
+                children: /*#__PURE__*/ jsx("input", {
+                    name: "email"
+                })
+            }));
+            await user.click(screen.getByRole('button', {
+                name: 'Submit'
+            }));
+            await waitFor(()=>{
+                expect(consoleError).toHaveBeenCalledWith('Form submission error:', expect.any(Error));
+            });
+            await waitFor(()=>{
+                const button = screen.getByRole('button', {
+                    name: 'Submit'
+                });
+                expect(button.disabled).toBe(false);
+            });
+            consoleError.mockRestore();
+        });
+    });
+});

package/dist/components/honeypot.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+/**
+ * Default honeypot field names - attractive to bots but NOT to browser autofill.
+ *
+ * We use prefixed names that:
+ * 1. Look like real fields to bots scanning for input names
+ * 2. Don't match browser autofill heuristics (email, phone, url, address patterns)
+ *
+ * The prefix "hp_" makes them unique enough to avoid autofill while
+ * the suffixes still look like fields bots want to fill.
+ */
+export declare const DEFAULT_HONEYPOT_FIELDS: readonly ["hp_contact_info", "hp_website_url", "hp_fax_number", "hp_company_name"];
+export interface HoneypotProps {
+    /** Callback when bot is detected (any honeypot field was filled) */
+    onBotDetected: () => void;
+    /** Custom field names (defaults to email_confirm, website, url, phone_number) */
+    fieldNames?: string[];
+}
+/**
+ * Hidden honeypot fields that bots typically fill out.
+ *
+ * These fields are invisible to humans but visible to bots
+ * that parse the DOM looking for form fields to fill.
+ *
+ * @example
+ * ```tsx
+ * <Honeypot onBotDetected={() => setIsBot(true)} />
+ * ```
+ */
+export declare function Honeypot({ onBotDetected, fieldNames, }: HoneypotProps): React.ReactElement;

package/dist/components/honeypot.js

@@ -0,0 +1,40 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useRef } from "react";
+const DEFAULT_HONEYPOT_FIELDS = [
+    'hp_contact_info',
+    'hp_website_url',
+    'hp_fax_number',
+    'hp_company_name'
+];
+function Honeypot({ onBotDetected, fieldNames = DEFAULT_HONEYPOT_FIELDS }) {
+    const hasTriggered = useRef(false);
+    const handleFieldChange = useCallback((e)=>{
+        if ('' !== e.target.value.trim() && !hasTriggered.current) {
+            hasTriggered.current = true;
+            onBotDetected();
+        }
+    }, [
+        onBotDetected
+    ]);
+    return /*#__PURE__*/ jsx("div", {
+        style: {
+            position: 'absolute',
+            left: '-9999px',
+            opacity: 0,
+            pointerEvents: 'none'
+        },
+        "aria-hidden": "true",
+        children: fieldNames.map((fieldName)=>/*#__PURE__*/ jsx("input", {
+                type: "text",
+                name: fieldName,
+                onChange: handleFieldChange,
+                tabIndex: -1,
+                autoComplete: "new-password",
+                "aria-hidden": "true",
+                "data-lpignore": "true",
+                "data-1p-ignore": "true"
+            }, fieldName))
+    });
+}
+export { DEFAULT_HONEYPOT_FIELDS, Honeypot };

package/dist/components/honeypot.test.d.ts

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

package/dist/components/honeypot.test.js

@@ -0,0 +1,186 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { afterEach, describe, expect, it, rs } from "@rstest/core";
+import { act, cleanup, fireEvent, render } from "@testing-library/react";
+import { DEFAULT_HONEYPOT_FIELDS, Honeypot } from "./honeypot.js";
+afterEach(()=>{
+    cleanup();
+});
+describe('Honeypot', ()=>{
+    describe('rendering', ()=>{
+        it('should render without crashing', ()=>{
+            const onBotDetected = rs.fn();
+            const { container } = render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            expect(container.firstChild).not.toBeNull();
+        });
+        it('should render hidden fields', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const hiddenWrapper = document.querySelector('[aria-hidden="true"]');
+            expect(hiddenWrapper).not.toBeNull();
+        });
+        it('should position fields off-screen', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const hiddenWrapper = document.querySelector('[aria-hidden="true"]');
+            expect(hiddenWrapper.style.position).toBe('absolute');
+            expect(hiddenWrapper.style.left).toBe('-9999px');
+        });
+        it('should render all default honeypot fields', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            for (const fieldName of DEFAULT_HONEYPOT_FIELDS)expect(document.querySelector(`[name="${fieldName}"]`)).not.toBeNull();
+        });
+    });
+    describe('bot detection', ()=>{
+        it('should not call onBotDetected when fields are empty', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            expect(onBotDetected).not.toHaveBeenCalled();
+        });
+        it('should call onBotDetected when any field is filled', async ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const websiteField = document.querySelector('[name="hp_website_url"]');
+            await act(async ()=>{
+                fireEvent.change(websiteField, {
+                    target: {
+                        value: 'spam-value'
+                    }
+                });
+            });
+            expect(onBotDetected).toHaveBeenCalledTimes(1);
+        });
+        it('should trigger on first field filled', async ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const contactField = document.querySelector('[name="hp_contact_info"]');
+            await act(async ()=>{
+                fireEvent.change(contactField, {
+                    target: {
+                        value: 'bot@spam.com'
+                    }
+                });
+            });
+            expect(onBotDetected).toHaveBeenCalledTimes(1);
+        });
+        it('should only trigger once even if multiple fields filled', async ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const websiteField = document.querySelector('[name="hp_website_url"]');
+            const faxField = document.querySelector('[name="hp_fax_number"]');
+            await act(async ()=>{
+                fireEvent.change(websiteField, {
+                    target: {
+                        value: 'spam1'
+                    }
+                });
+                fireEvent.change(faxField, {
+                    target: {
+                        value: 'spam2'
+                    }
+                });
+            });
+            expect(onBotDetected).toHaveBeenCalledTimes(1);
+        });
+        it('should not trigger on whitespace-only input', async ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const websiteField = document.querySelector('[name="hp_website_url"]');
+            await act(async ()=>{
+                fireEvent.change(websiteField, {
+                    target: {
+                        value: '   '
+                    }
+                });
+            });
+            expect(onBotDetected).not.toHaveBeenCalled();
+        });
+    });
+    describe('accessibility', ()=>{
+        it('should have aria-hidden attribute on wrapper', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const hiddenWrapper = document.querySelector('[aria-hidden="true"]');
+            expect(hiddenWrapper).not.toBeNull();
+        });
+        it('should have tabindex -1 on fields', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const field = document.querySelector('[name="hp_contact_info"]');
+            expect(field.tabIndex).toBe(-1);
+        });
+        it('should have autocomplete new-password on fields to prevent autofill', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const field = document.querySelector('[name="hp_contact_info"]');
+            expect(field.getAttribute('autocomplete')).toBe('new-password');
+        });
+        it('should have password manager ignore attributes', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected
+            }));
+            const field = document.querySelector('[name="hp_contact_info"]');
+            expect(field.getAttribute('data-lpignore')).toBe('true');
+            expect(field.getAttribute('data-1p-ignore')).toBe('true');
+        });
+    });
+    describe('custom field names', ()=>{
+        it('should use custom field names', ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected,
+                fieldNames: [
+                    'custom_trap',
+                    'fake_phone'
+                ]
+            }));
+            expect(document.querySelector('[name="custom_trap"]')).not.toBeNull();
+            expect(document.querySelector('[name="fake_phone"]')).not.toBeNull();
+            expect(document.querySelector('[name="email_confirm"]')).toBeNull();
+        });
+        it('should trigger detection on custom fields', async ()=>{
+            const onBotDetected = rs.fn();
+            render(/*#__PURE__*/ jsx(Honeypot, {
+                onBotDetected: onBotDetected,
+                fieldNames: [
+                    'my_honeypot'
+                ]
+            }));
+            const customField = document.querySelector('[name="my_honeypot"]');
+            await act(async ()=>{
+                fireEvent.change(customField, {
+                    target: {
+                        value: 'bot-filled'
+                    }
+                });
+            });
+            expect(onBotDetected).toHaveBeenCalled();
+        });
+    });
+});

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export { Honeypot, DEFAULT_HONEYPOT_FIELDS } from './honeypot';
+export type { HoneypotProps } from './honeypot';
+export { BotProtectedForm } from './bot-protected-form';
+export type { BotProtectedFormProps } from './bot-protected-form';

package/dist/components/index.js

@@ -0,0 +1,3 @@
+import { DEFAULT_HONEYPOT_FIELDS, Honeypot } from "./honeypot.js";
+import { BotProtectedForm } from "./bot-protected-form.js";
+export { BotProtectedForm, DEFAULT_HONEYPOT_FIELDS, Honeypot };

package/dist/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useBotDetection } from './use-bot-detection';
+export type { UseBotDetectionReturn } from './use-bot-detection';
+export { useHoneypot } from './use-honeypot';
+export type { UseHoneypotReturn } from './use-honeypot';

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+import { useBotDetection } from "./use-bot-detection.js";
+import { useHoneypot } from "./use-honeypot.js";
+export { useBotDetection, useHoneypot };

package/dist/hooks/use-bot-detection.d.ts

@@ -0,0 +1,31 @@
+import type { BotDetectionResult, BotDetectionStats } from '../types';
+export interface UseBotDetectionReturn {
+    botScore: number;
+    detectionReasons: string[];
+    isBot: boolean;
+    analyzeBehavior: () => BotDetectionResult;
+    handleFieldFocus: () => void;
+    handleFormSubmit: () => BotDetectionResult;
+    stats: BotDetectionStats;
+}
+/**
+ * Hook for behavioral bot detection.
+ *
+ * Tracks mouse movements, typing patterns, and form interactions
+ * to detect automated form submissions.
+ *
+ * @example
+ * ```tsx
+ * const { handleFormSubmit, isBot } = useBotDetection();
+ *
+ * const onSubmit = () => {
+ *   const result = handleFormSubmit();
+ *   if (result.isBot) {
+ *     console.log('Bot detected:', result.reasons);
+ *     return;
+ *   }
+ *   // Proceed with submission
+ * };
+ * ```
+ */
+export declare function useBotDetection(): UseBotDetectionReturn;