import { ReactNode, FC, Ref, ForwardRefRenderFunction, ForwardRefExoticComponent, RefAttributes } from 'react';
import { Equality, SelectorContext } from '../types';

export interface WithStoreOptions<TOutput extends object> {
    displayName?: string;
    /**
     * Custom equality function for comparing hook output.
     * Controls when the memoized render function re-renders.
     *
     * Note: To control input props equality, wrap the final component with memo().
     */
    equality?: Equality<TOutput>;
}
/**
 * Hook function that receives SelectorContext and props.
 *
 * Can use:
 * - Store access via ctx.get()
 * - React hooks (useState, useEffect, useMemo, etc.)
 * - Return any values including functions
 *
 * The hook is called during render phase, so all React hooks rules apply.
 *
 * ⚠️ Limitation: Cannot use React hooks inside pick() callbacks:
 * ```tsx
 * // ❌ DON'T: React hooks inside pick callback
 * const value = ctx.pick(store, state => {
 *   const [x] = useState(0); // ❌ Error: Invalid hook call
 *   return state.value + x;
 * });
 *
 * // ✅ DO: React hooks outside pick
 * const [x] = useState(0);
 * const value = ctx.pick(store, state => state.value + x);
 * ```
 *
 * @example
 * ```tsx
 * const Component = withStore(
 *   (ctx, { userId }) => {
 *     const [user] = ctx.get(userStore);
 *     const [count, setCount] = useState(0);
 *
 *     return {
 *       userName: user.name,
 *       count,
 *       increment: () => setCount(c => c + 1), // ✅ Can return functions
 *     };
 *   },
 *   ({ userName, count, increment }) => (
 *     <div onClick={increment}>{userName}: {count}</div>
 *   )
 * );
 * ```
 */
export type WithStoreHook<TInput extends object, TOutput extends object> = (context: SelectorContext, props: TInput) => TOutput;
/**
 * Render function without ref support.
 */
export type WithStoreRender<TOutput extends object> = (props: TOutput) => ReactNode;
/**
 * Render function with ref support.
 */
export type WithStoreRenderWithRef<TOutput extends object, TRef = unknown> = (props: TOutput, ref: Ref<TRef>) => ReactNode;
/**
 * Testing utilities exposed on components created with withStore(hook, render)
 */
export interface WithStoreTestUtils<TInput extends object, TOutput extends object, TContext = SelectorContext> {
    /**
     * The hook function for testing.
     * Call this to test the hook logic independently.
     *
     * @example
     * ```ts
     * const result = MyComponent.use(mockCtx, { userId: '123' });
     * expect(result.name).toBe('John');
     * ```
     */
    use: (context: TContext, props: TInput) => TOutput;
    /**
     * The render function for testing.
     * Call this to test the render output independently.
     *
     * @example
     * ```tsx
     * const element = MyComponent.render({ name: 'John' });
     * // Or with testing-library:
     * render(MyComponent.render({ name: 'John' }));
     * ```
     */
    render: (props: TOutput) => ReactNode;
}
/**
 * Testing utilities exposed on HOCs created with withStore(hook)
 */
export interface WithStoreHOCTestUtils<TInput extends object, TOutput extends object, TContext = SelectorContext> {
    /**
     * The hook function for testing.
     * Call this to test the hook logic independently.
     *
     * @example
     * ```ts
     * const result = withUserData.use(mockCtx, { userId: '123' });
     * expect(result.name).toBe('John');
     * ```
     */
    use: (context: TContext, props: TInput) => TOutput;
}
/**
 * Component type with testing utilities (no ref)
 */
export type WithStoreComponent<TInput extends object, TOutput extends object, TContext = SelectorContext> = FC<TInput> & WithStoreTestUtils<TInput, TOutput, TContext>;
/**
 * Component type with testing utilities (with ref)
 */
export type WithStoreComponentWithRef<TInput extends object, TOutput extends object, TRef = unknown, TContext = SelectorContext> = ForwardRefExoticComponent<TInput & RefAttributes<TRef>> & WithStoreTestUtils<TInput, TOutput, TContext>;
/**
 * HOC type with testing utilities
 */
export type WithStoreHOC<TInput extends object, TOutput extends object, TContext = SelectorContext> = {
    (component: FC<TOutput>): FC<TInput>;
    <TRef = unknown>(component: ForwardRefRenderFunction<TRef, TOutput>): ForwardRefExoticComponent<TInput & RefAttributes<TRef>>;
} & WithStoreHOCTestUtils<TInput, TOutput, TContext>;
/**
 * Generic hook type for createWithStore
 */
export type GenericWithStoreHook<TContext, TInput extends object, TOutput extends object> = (context: TContext, props: TInput) => TOutput;
/**
 * WithStore function type bound to a specific context type.
 */
export interface BoundWithStore<TContext> {
    /**
     * Direct mode: Create component with hook and render function (no ref).
     */
    <TInput extends object, TOutput extends object>(hook: GenericWithStoreHook<TContext, TInput, TOutput>, render: WithStoreRender<TOutput>, options?: WithStoreOptions<TOutput>): WithStoreComponent<TInput, TOutput, TContext>;
    /**
     * Direct mode: Create component with hook and render function (with ref).
     */
    <TInput extends object, TOutput extends object, TRef = unknown>(hook: GenericWithStoreHook<TContext, TInput, TOutput>, render: WithStoreRenderWithRef<TOutput, TRef>, options?: WithStoreOptions<TOutput>): WithStoreComponentWithRef<TInput, TOutput, TRef, TContext>;
    /**
     * HOC mode: Create HOC that transforms props using hook.
     */
    <TInput extends object, TOutput extends object>(hook: GenericWithStoreHook<TContext, TInput, TOutput>, options?: WithStoreOptions<TOutput>): WithStoreHOC<TInput, TOutput, TContext>;
}
/**
 * A reactive hook that accepts a selector and returns the selected value.
 * Similar to useStore's signature.
 */
export type UseContextHook<TContext> = <T extends object>(selector: (ctx: TContext) => T) => T;
/**
 * Create a withStore function bound to a custom reactive hook.
 *
 * This is the core building block for creating withStore-like patterns with custom contexts.
 * Useful for single-store apps or custom store patterns.
 *
 * @example
 * ```tsx
 * // For single-store apps with create()
 * const [counter, useCounter] = create({
 *   state: { count: 0 },
 *   setup({ state }) {
 *     return { increment: () => state.count++ };
 *   }
 * });
 *
 * // Create withStore bound to this store's hook
 * const withCounter = createWithStore(useCounter);
 *
 * // Direct mode - hook receives (state, actions) instead of SelectorContext
 * const Display = withCounter(
 *   (state, actions, props: { multiplier: number }) => ({
 *     count: state.count * props.multiplier,
 *     increment: actions.increment,
 *   }),
 *   ({ count, increment }) => <button onClick={increment}>{count}</button>
 * );
 *
 * // HOC mode
 * const withData = withCounter((state) => ({
 *   value: state.count,
 * }));
 * const ValueDisplay = withData(({ value }) => <div>{value}</div>);
 * ```
 *
 * @param useContextHook - A reactive hook that accepts a selector (like useStore or useCreatedStore)
 * @returns A withStore function bound to the custom context
 */
export declare function createWithStore<TContext>(useContextHook: UseContextHook<TContext>): BoundWithStore<TContext>;
/**
 * Direct mode: Create component with hook and render function (no ref).
 * Returns component with `use` and `render` properties for testing.
 */
export declare function withStore<TInput extends object, TOutput extends object>(hook: WithStoreHook<TInput, TOutput>, render: WithStoreRender<TOutput>, options?: WithStoreOptions<TOutput>): WithStoreComponent<TInput, TOutput>;
/**
 * Direct mode: Create component with hook and render function (with ref).
 * Automatically detected when render function has 2 parameters.
 * Returns component with `use` and `render` properties for testing.
 */
export declare function withStore<TInput extends object, TOutput extends object, TRef = unknown>(hook: WithStoreHook<TInput, TOutput>, render: WithStoreRenderWithRef<TOutput, TRef>, options?: WithStoreOptions<TOutput>): WithStoreComponentWithRef<TInput, TOutput, TRef>;
/**
 * HOC mode: Create HOC that transforms props using hook.
 * Returns a function that accepts a component, with `use` property for testing.
 */
export declare function withStore<TInput extends object, TOutput extends object>(hook: WithStoreHook<TInput, TOutput>, options?: WithStoreOptions<TOutput>): WithStoreHOC<TInput, TOutput>;
//# sourceMappingURL=withStore.d.ts.map