import { Middleware, MiddlewareContext, StoreMiddleware } from '../types';

/** Pattern type for matching displayName */
export type SpecPattern = string | RegExp;
/** Mapping of patterns to middleware */
export type MiddlewareMap = Record<string, StoreMiddleware | StoreMiddleware[]>;
/**
 * Conditionally apply middleware based on a predicate or pattern(s).
 *
 * @overload Apply middleware when predicate returns true
 * @param predicate - Function that receives context and returns whether to apply middleware
 * @param middleware - Middleware or array of middleware to apply
 *
 * @overload Apply middleware for matching pattern(s)
 * @param patterns - Pattern or array of patterns to match displayName
 * @param middleware - Middleware or array of middleware to apply
 *
 * @overload Apply different middleware for different patterns (object form)
 * @param middlewareMap - Object mapping patterns to middleware
 *
 * Pattern types:
 * - `"userStore"` - exact match
 * - `"user*"` - startsWith
 * - `"*Store"` - endsWith
 * - `"*auth*"` - includes
 * - `/^(user|auth)/` - RegExp
 *
 * @example
 * ```ts
 * // Exact match
 * applyFor("userStore", loggingMiddleware);
 *
 * // Wildcard patterns
 * applyFor("user*", loggingMiddleware);       // userStore, userCache, etc.
 * applyFor("*Store", loggingMiddleware);      // userStore, authStore, etc.
 * applyFor("*auth*", loggingMiddleware);      // authStore, userAuth, etc.
 *
 * // RegExp
 * applyFor(/^(user|auth)Store$/, loggingMiddleware);
 *
 * // Multiple patterns
 * applyFor(["userStore", "auth*"], loggingMiddleware);
 *
 * // Predicate function (using meta query)
 * applyFor(
 *   (ctx) => ctx.type === "store" && ctx.meta.any(persist),
 *   persistMiddleware
 * );
 *
 * // Multiple middleware
 * applyFor("counterStore", [loggingMiddleware, devtoolsMiddleware]);
 *
 * // Object form - map patterns to middleware
 * applyFor({
 *   "userStore": loggingMiddleware,
 *   "auth*": [authMiddleware, securityMiddleware],
 *   "*Cache": cacheMiddleware,
 * });
 * ```
 */
export declare function applyFor(predicate: (ctx: MiddlewareContext) => boolean, middleware: Middleware | Middleware[]): Middleware;
export declare function applyFor(patterns: SpecPattern | SpecPattern[], middleware: StoreMiddleware | StoreMiddleware[]): Middleware;
export declare function applyFor(middlewareMap: MiddlewareMap): Middleware;
/**
 * Apply middleware to all except those matching predicate or pattern(s).
 *
 * @overload Exclude matching predicate
 * @param predicate - Function that receives context and returns whether to exclude
 * @param middleware - Middleware or array of middleware to apply
 *
 * @overload Exclude matching pattern(s)
 * @param patterns - Pattern or array of patterns to exclude
 * @param middleware - Middleware or array of middleware to apply
 *
 * @example
 * ```ts
 * // Exclude by predicate
 * applyExcept(
 *   (ctx) => ctx.displayName?.startsWith("_") ?? false,
 *   loggingMiddleware
 * );
 *
 * // Exclude exact names
 * applyExcept(["tempStore", "cacheStore"], persist);
 *
 * // Exclude with wildcards
 * applyExcept("_*", loggingMiddleware);        // exclude _internal, _temp, etc.
 * applyExcept("*Cache", persist);    // exclude userCache, dataCache, etc.
 *
 * // Exclude with RegExp
 * applyExcept(/^(temp|cache)/, persist);
 * ```
 */
export declare function applyExcept(predicate: (ctx: MiddlewareContext) => boolean, middleware: Middleware | Middleware[]): Middleware;
export declare function applyExcept(patterns: SpecPattern | SpecPattern[], middleware: Middleware | Middleware[]): Middleware;
/**
 * Helper to create store-only middleware.
 * The middleware will only run for stores, not plain factories.
 *
 * @example
 * ```ts
 * const storeLogger = forStores((ctx) => {
 *   console.log(`Creating store: ${ctx.spec.displayName}`);
 *   return ctx.next();
 * });
 * ```
 */
export declare function forStores(storeMiddleware: StoreMiddleware | StoreMiddleware[]): Middleware;
//# sourceMappingURL=middleware.d.ts.map