import * as solid_js from 'solid-js';
import { Accessor } from 'solid-js';
import { createRequirementStatusPlugin, SingleModuleSystem, ModuleSchema, InferFacts, InferDerivations, InferEvents, AuditLedger, QueryFilter, AuditEntry, ModuleDef, Plugin, TraceOption, ErrorBoundaryConfig, RequirementTypeStatus, ModulesMap, NamespacedSystem, InferSelectorState } from '@directive-run/core';
export { RequirementTypeStatus } from '@directive-run/core';
import { ConstraintInfo, buildHistoryState, InspectState } from '@directive-run/core/adapter-utils';
export { ConstraintInfo, InspectState, shallowEqual } from '@directive-run/core/adapter-utils';

/** Type for the requirement status plugin return value */
type StatusPlugin = ReturnType<typeof createRequirementStatusPlugin>;
/** Single key overload */
declare function useFact<S extends ModuleSchema, K extends keyof InferFacts<S> & string>(system: SingleModuleSystem<S>, factKey: K): Accessor<InferFacts<S>[K] | undefined>;
/** Multi-key overload */
declare function useFact<S extends ModuleSchema, K extends keyof InferFacts<S> & string>(system: SingleModuleSystem<S>, factKeys: K[]): Accessor<Pick<InferFacts<S>, K>>;
/** Single key overload */
declare function useDerived<S extends ModuleSchema, K extends keyof InferDerivations<S> & string>(system: SingleModuleSystem<S>, derivationId: K): Accessor<InferDerivations<S>[K]>;
/** Multi-key overload */
declare function useDerived<S extends ModuleSchema, K extends keyof InferDerivations<S> & string>(system: SingleModuleSystem<S>, derivationIds: K[]): Accessor<Pick<InferDerivations<S>, K>>;
/**
 * Auto-tracking selector over facts and derivations.
 * Uses `withTracking()` to detect which facts the selector accesses,
 * then subscribes only to those keys.
 */
declare function useSelector<S extends ModuleSchema, R>(system: SingleModuleSystem<S>, selector: (state: InferSelectorState<S>) => R, equalityFn?: (a: R, b: R) => boolean): Accessor<R>;
declare function useDispatch<S extends ModuleSchema>(system: SingleModuleSystem<S>): (event: InferEvents<S>) => void;
/**
 * Returns the system's events dispatcher.
 */
declare function useEvents<S extends ModuleSchema>(system: SingleModuleSystem<S>): SingleModuleSystem<S>["events"];
/** Watch a derivation or fact by key (auto-detected). When a key exists in both facts and derivations, the derivation overload takes priority. */
declare function useWatch<S extends ModuleSchema, K extends keyof InferDerivations<S> & string>(system: SingleModuleSystem<S>, key: K, callback: (newValue: InferDerivations<S>[K], previousValue: InferDerivations<S>[K] | undefined) => void): void;
/** Watch a fact key with auto-detection. */
declare function useWatch<S extends ModuleSchema, K extends keyof InferFacts<S> & string>(system: SingleModuleSystem<S>, key: K, callback: (newValue: InferFacts<S>[K] | undefined, previousValue: InferFacts<S>[K] | undefined) => void): void;
/** Options for useInspect */
interface UseInspectOptions {
    throttleMs?: number;
}
/**
 * Consolidated system inspection hook.
 * Returns Accessor<InspectState> with optional throttling.
 */
declare function useInspect(system: SingleModuleSystem<any>, options?: UseInspectOptions): Accessor<InspectState>;
/** Single type overload */
declare function useRequirementStatus(statusPlugin: StatusPlugin, type: string): Accessor<RequirementTypeStatus>;
/** Multi-type overload */
declare function useRequirementStatus(statusPlugin: StatusPlugin, types: string[]): Accessor<Record<string, RequirementTypeStatus>>;
/**
 * Reactively returns the explanation string for a requirement.
 */
declare function useExplain(system: SingleModuleSystem<any>, requirementId: string): Accessor<string | null>;
/** Get all constraints */
declare function useConstraintStatus(system: SingleModuleSystem<any>): Accessor<ConstraintInfo[]>;
/** Get a single constraint by ID */
declare function useConstraintStatus(system: SingleModuleSystem<any>, constraintId: string): Accessor<ConstraintInfo | null>;
interface OptimisticUpdateResult {
    mutate: (updateFn: () => void) => void;
    isPending: Accessor<boolean>;
    error: Accessor<Error | null>;
    rollback: () => void;
}
/**
 * Optimistic update hook. Saves a snapshot before mutating, monitors
 * a requirement type via statusPlugin, and rolls back on failure.
 */
declare function useOptimisticUpdate(system: SingleModuleSystem<any>, statusPlugin?: StatusPlugin, requirementType?: string): OptimisticUpdateResult;
/**
 * Single type: throws a promise while the requirement is pending (Suspense).
 */
declare function useSuspenseRequirement(statusPlugin: StatusPlugin, type: string): Accessor<RequirementTypeStatus>;
/**
 * Multi-type: throws a promise while any of the requirements are pending.
 */
declare function useSuspenseRequirement(statusPlugin: StatusPlugin, types: string[]): Accessor<Record<string, RequirementTypeStatus>>;
/**
 * Reactive history signal. Returns an Accessor that updates
 * when snapshots are taken or navigation occurs.
 *
 * @example
 * ```tsx
 * const history = useHistory(system);
 * <button disabled={!history()?.canGoBack} onClick={() => history()?.goBack()}>Undo</button>
 * ```
 */
declare function useHistory(system: SingleModuleSystem<any>): Accessor<ReturnType<typeof buildHistoryState>>;
/** Configuration for useDirective */
interface UseDirectiveConfig {
    plugins?: Plugin<any>[];
    trace?: TraceOption;
    errorBoundary?: ErrorBoundaryConfig;
    tickMs?: number;
    zeroConfig?: boolean;
    initialFacts?: Record<string, any>;
    status?: boolean;
    /** Fact keys to subscribe to (omit for all) */
    facts?: string[];
    /** Derivation keys to subscribe to (omit for all) */
    derived?: string[];
}
/**
 * Create a scoped Directive system with automatic lifecycle management.
 * When no `facts` or `derived` keys are specified, subscribes to ALL
 * facts and derivations and returns reactive signals.
 *
 * @example
 * ```tsx
 * // Subscribe to everything
 * const { facts, derived, events, dispatch } = useDirective(counterModule);
 *
 * // Selective keys
 * const { facts, derived } = useDirective(counterModule, { facts: ["count"], derived: ["doubled"] });
 * ```
 */
declare function useDirective<M extends ModuleSchema>(moduleDef: ModuleDef<M>, config?: UseDirectiveConfig): {
    system: SingleModuleSystem<M>;
    facts: Accessor<InferFacts<M>>;
    derived: Accessor<InferDerivations<M>>;
    events: M["events"] extends Record<string, unknown> ? { [E in keyof M["events"]]: M["events"][E] extends Record<string, unknown> ? keyof M["events"][E] extends never ? () => void : (payload: M["events"][E] extends infer T ? T extends M["events"][E] ? T extends Record<string, unknown> ? { [K in keyof T]: T[K] extends {
        _type: infer T_1;
    } ? T_1 : T[K]; } : never : never : never) => void : () => void; } : Record<string, never>;
    dispatch: (event: InferEvents<M>) => void;
    statusPlugin: {
        plugin: Plugin<never>;
        getStatus: (type: string) => RequirementTypeStatus;
        getAllStatus: () => Map<string, RequirementTypeStatus>;
        subscribe: (listener: () => void) => () => void;
        reset: () => void;
    } | undefined;
};
/**
 * Create a derivation signal outside of a component.
 */
declare function createDerivedSignal<T>(system: SingleModuleSystem<any>, derivationId: string): [Accessor<T>, () => void];
/**
 * Create a fact signal outside of a component.
 */
declare function createFactSignal<T>(system: SingleModuleSystem<any>, factKey: string): [Accessor<T | undefined>, () => void];
declare function createTypedHooks<M extends ModuleSchema>(): {
    useFact: <K extends keyof InferFacts<M> & string>(system: SingleModuleSystem<M>, factKey: K) => Accessor<InferFacts<M>[K] | undefined>;
    useDerived: <K extends keyof InferDerivations<M> & string>(system: SingleModuleSystem<M>, derivationId: K) => Accessor<InferDerivations<M>[K]>;
    useDispatch: (system: SingleModuleSystem<M>) => (event: InferEvents<M>) => void;
    useEvents: (system: SingleModuleSystem<M>) => SingleModuleSystem<M>["events"];
    useWatch: <K extends string>(system: SingleModuleSystem<M>, key: K, callback: (newValue: unknown, previousValue: unknown) => void) => void;
};
/**
 * SolidJS accessor that selects from a NamespacedSystem.
 * Subscribes to specified keys and provides reactive updates.
 *
 * @param system - The namespaced system
 * @param keys - Namespaced keys to subscribe to (e.g., ["auth.token", "data.count"])
 * @param selector - Function that reads from system.facts / system.derive
 *
 * @example
 * ```tsx
 * const token = useNamespacedSelector(system, ["auth.token"], (s) => s.facts.auth.token);
 * ```
 */
declare function useNamespacedSelector<Modules extends ModulesMap, R>(system: NamespacedSystem<Modules>, keys: string[], selector: (system: NamespacedSystem<Modules>) => R): Accessor<R>;
/**
 * Solid composable to create and manage a query system with proper lifecycle.
 *
 * Accepts a config object or a factory function that creates the system.
 * Handles cleanup via onCleanup.
 *
 * @example
 * ```tsx
 * import { useQuerySystem, useDerived } from "@directive-run/solid";
 *
 * function App() {
 *   const app = useQuerySystem({
 *     facts: { userId: "" },
 *     queries: { user: { key: ..., fetcher: ... } },
 *   });
 *
 *   const user = useDerived(app, "user");
 *   return <div>{user().data?.name}</div>;
 * }
 * ```
 */
declare function useQuerySystem<T extends {
    start: () => void;
    destroy: () => void;
    isRunning?: boolean;
    [key: string]: any;
}>(config: Record<string, unknown>): T;
/**
 * Solid component that provides a DistributableSnapshot to child components.
 * Uses `HydrationContext.Provider` under the hood — pass `value` as the snapshot.
 *
 * @example
 * ```tsx
 * <DirectiveHydrator value={snapshot}>
 *   <App />
 * </DirectiveHydrator>
 * ```
 */
declare const DirectiveHydrator: solid_js.ContextProviderComponent<Record<string, unknown> | undefined>;
/**
 * Create a system hydrated from a server snapshot.
 * Must be used inside a `<DirectiveHydrator>` ancestor.
 */
declare function useHydratedSystem<S extends ModuleSchema>(moduleDef: ModuleDef<S>, config?: UseDirectiveConfig): SingleModuleSystem<S>;

/**
 * Subscribe to an audit ledger and return the latest entries matching
 * `filter` as a Solid `Accessor`. Re-evaluates on each poll tick
 * (default 250 ms — override with `pollMs`).
 *
 * **Polling floor:** `pollMs` is clamped to a minimum of 50 ms to prevent
 * accidental DoS from typos like `pollMs: 5`. Values below the floor are
 * silently clamped in production; dev mode logs a warning.
 *
 * @example
 * ```tsx
 * import { useAuditLedger } from "@directive-run/solid";
 *
 * function AuditLog(props: { ledger: AuditLedger }) {
 *   const entries = useAuditLedger(props.ledger, { kind: "constraint.evaluate", limit: 20 });
 *   return (
 *     <ul>
 *       <For each={entries()}>
 *         {(e) => <li>{e.kind} @ {new Date(e.ts).toISOString()}</li>}
 *       </For>
 *     </ul>
 *   );
 * }
 * ```
 */
declare function useAuditLedger(ledger: AuditLedger, filter?: QueryFilter, opts?: {
    pollMs?: number;
}): Accessor<readonly AuditEntry[]>;

export { DirectiveHydrator, type OptimisticUpdateResult, type StatusPlugin, type UseInspectOptions, createDerivedSignal, createFactSignal, createTypedHooks, useAuditLedger, useConstraintStatus, useDerived, useDirective, useDispatch, useEvents, useExplain, useFact, useHistory, useHydratedSystem, useInspect, useNamespacedSelector, useOptimisticUpdate, useQuerySystem, useRequirementStatus, useSelector, useSuspenseRequirement, useWatch };