import * as vue from 'vue';
import { Ref, ShallowRef, ComputedRef } from 'vue';
import { createRequirementStatusPlugin, ModuleSchema, InferFacts, SingleModuleSystem, 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): Ref<InferFacts<S>[K] | undefined>;
/** Multi-key overload */
declare function useFact<S extends ModuleSchema, K extends keyof InferFacts<S> & string>(system: SingleModuleSystem<S>, factKeys: K[]): ShallowRef<Pick<InferFacts<S>, K>>;
/** Single key overload */
declare function useDerived<S extends ModuleSchema, K extends keyof InferDerivations<S> & string>(system: SingleModuleSystem<S>, derivationId: K): Ref<InferDerivations<S>[K]>;
/** Multi-key overload */
declare function useDerived<S extends ModuleSchema, K extends keyof InferDerivations<S> & string>(system: SingleModuleSystem<S>, derivationIds: K[]): ShallowRef<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): Ref<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 InspectState with optional throttling.
 */
declare function useInspect(system: SingleModuleSystem<any>, options?: UseInspectOptions): ShallowRef<InspectState>;
/** Single type overload */
declare function useRequirementStatus(statusPlugin: StatusPlugin, type: string): ShallowRef<RequirementTypeStatus>;
/** Multi-type overload */
declare function useRequirementStatus(statusPlugin: StatusPlugin, types: string[]): ShallowRef<Record<string, RequirementTypeStatus>>;
/**
 * Returns a promise that resolves when a requirement type settles.
 * Designed for Vue's async `setup()` with `<Suspense>`.
 *
 * - If the requirement is loading, the returned promise suspends the component.
 * - If the requirement has an error, the promise rejects with that error.
 * - If the requirement is already settled, resolves immediately.
 *
 * @example
 * ```vue
 * <script setup>
 * import { useSuspenseRequirement } from '@directive-run/vue';
 *
 * // In async setup(), this suspends until FETCH_USER settles
 * const status = await useSuspenseRequirement(statusPlugin, "FETCH_USER");
 * </script>
 *
 * <template>
 *   <div>Resolved: {{ status.resolvedCount }}</div>
 * </template>
 * ```
 */
/** Single type overload */
declare function useSuspenseRequirement(statusPlugin: StatusPlugin, type: string): Promise<ShallowRef<RequirementTypeStatus>>;
/** Multi-type overload */
declare function useSuspenseRequirement(statusPlugin: StatusPlugin, types: string[]): Promise<ShallowRef<Record<string, RequirementTypeStatus>>>;
/**
 * Reactively returns the explanation string for a requirement.
 */
declare function useExplain(system: SingleModuleSystem<any>, requirementId: string): Ref<string | null>;
/** Get all constraints */
declare function useConstraintStatus(system: SingleModuleSystem<any>): ComputedRef<ConstraintInfo[]>;
/** Get a single constraint by ID */
declare function useConstraintStatus(system: SingleModuleSystem<any>, constraintId: string): ComputedRef<ConstraintInfo | null>;
interface OptimisticUpdateResult {
    mutate: (updateFn: () => void) => void;
    isPending: Ref<boolean>;
    error: Ref<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;
/**
 * Reactive history composable. Returns a ShallowRef that updates
 * when snapshots are taken or navigation occurs.
 *
 * @example
 * ```vue
 * const history = useHistory(system);
 * <button :disabled="!history.value?.canGoBack" @click="history.value?.goBack()">Undo</button>
 * ```
 */
declare function useHistory(system: SingleModuleSystem<any>): ShallowRef<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[];
}
declare function useDirective<M extends ModuleSchema>(moduleDef: ModuleDef<M>, config?: UseDirectiveConfig): {
    system: SingleModuleSystem<M>;
    facts: ShallowRef<InferFacts<M>>;
    derived: ShallowRef<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;
};
declare function createTypedHooks<M extends ModuleSchema>(): {
    useFact: <K extends keyof InferFacts<M> & string>(system: SingleModuleSystem<M>, factKey: K) => Ref<InferFacts<M>[K] | undefined>;
    useDerived: <K extends keyof InferDerivations<M> & string>(system: SingleModuleSystem<M>, derivationId: K) => Ref<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;
};
/**
 * Reactive composable to select from a NamespacedSystem.
 * Subscribes to specified keys and returns a Vue ref.
 *
 * @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
 * ```vue
 * const system = useDirectiveRef({ modules: { auth, data } });
 * 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): Ref<R>;
/**
 * Vue 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 on scope disposal.
 *
 * @example
 * ```vue
 * <script setup>
 * import { useQuerySystem, useDerived } from "@directive-run/vue";
 *
 * const app = useQuerySystem({
 *   facts: { userId: "" },
 *   queries: { user: { key: ..., fetcher: ... } },
 * });
 *
 * const user = useDerived(app, "user");
 * </script>
 * ```
 */
declare function useQuerySystem<T extends {
    start: () => void;
    destroy: () => void;
    isRunning?: boolean;
    [key: string]: any;
}>(config: Record<string, unknown>): T;
/**
 * Vue component that provides a DistributableSnapshot to child components.
 * Use with `useHydratedSystem` for SSR hydration in Nuxt or Vue SSR apps.
 *
 * @example
 * ```vue
 * <template>
 *   <DirectiveHydrator :snapshot="snapshot">
 *     <App />
 *   </DirectiveHydrator>
 * </template>
 * ```
 */
declare const DirectiveHydrator: vue.DefineComponent<vue.ExtractPropTypes<{
    snapshot: {
        type: ObjectConstructor;
        required: true;
    };
}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
    [key: string]: any;
}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
    snapshot: {
        type: ObjectConstructor;
        required: true;
    };
}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
/**
 * Vue composable that creates a system hydrated from a server snapshot.
 * Must be used inside a `<DirectiveHydrator>` ancestor.
 *
 * @example
 * ```vue
 * <script setup>
 * import { useHydratedSystem, useDerived } from "@directive-run/vue";
 * const system = useHydratedSystem(myModule);
 * const count = useDerived(system, "count");
 * </script>
 * ```
 */
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 reactive `Ref`. 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.
 *
 * **First-paint freshness:** the interval starts immediately at setup
 * time (not gated on `onMounted`), so the first ledger query lands
 * before the component paints. Cleanup uses `onScopeDispose`, which
 * is correct for both component scopes and ad-hoc effect scopes.
 *
 * @example
 * ```vue
 * <script setup>
 * import { useAuditLedger } from "@directive-run/vue";
 * const entries = useAuditLedger(ledger, { kind: "constraint.evaluate", limit: 20 });
 * </script>
 * <template>
 *   <ul>
 *     <li v-for="e in entries" :key="e.seq">{{ e.kind }} @ {{ e.ts }}</li>
 *   </ul>
 * </template>
 * ```
 */
declare function useAuditLedger(ledger: AuditLedger, filter?: QueryFilter, opts?: {
    pollMs?: number;
}): ShallowRef<readonly AuditEntry[]>;

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