import { m as CacheState, r as Cache, t as Scope } from "./scope-qdOAlRWQ.js";
import { B as Value, C as Selector, K as Constrain, N as Path, T as Update, r as Store, w as SubscribeOptions } from "./store-Cq1PqvEo.js";
import { Context, ReactNode } from "react";

//#region src/react/useStore.d.ts
interface UseStoreOptions<T> extends Omit<SubscribeOptions, "runNow" | "passive"> {
  /**
  * If true, the cache content can be consumed but no fetch will be triggered.
  * @default false
  */
  passive?: boolean;
  /**
  * (experimental) If true, the a rerender will only be triggered when a property of the returned value changes that was
  * actually accessed during the last render.
  * @default false
  */
  enableTrackingProxy?: boolean;
  /**
  * (experimental) If provided, a rerender will be wrapped in a browser view transition.
  */
  withViewTransition?: boolean | ((value: T) => unknown);
}
interface UseStoreOptionsWithSelector<T, S> extends UseStoreOptions<S> {
  /**
  * Equality function to compare the raw store values before reevaluating the selector.
  * Can be used to avoid unnecessary selector evaluations.
  * @default strictEqual
  */
  storeValueEquals?: (newValue: T, oldValue: T) => boolean;
}
declare function useStore<T, S>(store: Store<T>, selector: Selector<T, S>, option?: UseStoreOptionsWithSelector<T, S>): S;
declare function useStore<T, const P>(store: Store<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptionsWithSelector<T, Value<T, P>>): Value<T, P>;
declare function useStore<T>(store: Store<T>, option?: UseStoreOptions<T>): T;
//#endregion
//#region src/react/useCache.d.ts
type UseCacheArray<T> = [value: T | undefined, error: unknown | undefined, isUpdating: boolean, isStale: boolean];
type UseCacheValue<T> = UseCacheArray<T> & CacheState<T>;
interface UseCacheOptions<T> extends UseStoreOptions<UseCacheArray<T> & CacheState<T>> {
  /**
  * If true, will always return undefined as value and no fetch will be triggered.
  * @default false
  */
  disabled?: boolean;
  /**
  * If true, the cache will be invalidated when the component mounts.
  * @default false
  */
  updateOnMount?: boolean;
  /**
  * If true, `useCache` will throw a promise when the cache is pending. This can be used with React Suspense.
  * @see https://react.dev/reference/react/Suspense
  * @default false
  */
  suspense?: boolean;
  /**
  * If true, `useCache` will register its loading state with the nearest `LoadingBoundary`.
  * @default false
  */
  loadingBoundary?: boolean;
}
declare function useCache<T>(cache: Cache<T, any>, {
  passive,
  disabled,
  updateOnMount,
  withViewTransition,
  suspense,
  loadingBoundary,
  ...options
}?: UseCacheOptions<T>): UseCacheValue<T>;
//#endregion
//#region src/react/cacheMethods.d.ts
declare const cacheMethods: {
  useCache<T>(this: Cache<T, any>, options?: UseCacheOptions<T>): UseCacheValue<T>;
};
//#endregion
//#region src/react/scope.d.ts
type ScopeProps<T> = {
  scope: Scope<T>;
  store?: Store<T>;
  children?: ReactNode;
};
declare module ".." {
  interface Scope<T> {
    context?: Context<Store<T>>;
  }
}
declare function ScopeProvider<T>({
  scope,
  store: inputStore,
  children
}: ScopeProps<T>): React.JSX.Element;
declare function useScope<T>(scope: Scope<T>): Store<T>;
//#endregion
//#region src/react/scopeMethods.d.ts
declare function boundUseScope<T>(this: Scope<T>): Store<T>;
declare function boundUseScopeStore<T, S>(this: Scope<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
declare function boundUseScopeStore<T, const P>(this: Scope<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
declare function boundUseScopeStore<T>(this: Scope<T>, option?: UseStoreOptions<T>): T;
declare function boundUseScopeProp<T, S>(this: Scope<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>["set"]];
declare function boundUseScopeProp<T, const P>(this: Scope<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>["set"]];
declare function boundUseScopeProp<T>(this: Scope<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>["set"]];
declare function Provider<T>(this: Scope<T>, props: Omit<ScopeProps<T>, "scope">): React.JSX.Element;
declare const scopeMethods: {
  useScope: typeof boundUseScope;
  useStore: typeof boundUseScopeStore;
  useProp: typeof boundUseScopeProp;
  Provider: typeof Provider;
};
//#endregion
//#region src/react/storeMethods.d.ts
declare function boundUseStore<T, S>(this: Store<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
declare function boundUseStore<T, const P>(this: Store<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
declare function boundUseStore<T>(this: Store<T>, option?: UseStoreOptions<T>): T;
declare function boundUseProp<T, S>(this: Store<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>["set"]];
declare function boundUseProp<T, const P>(this: Store<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>["set"]];
declare function boundUseProp<T>(this: Store<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>["set"]];
declare const storeMethods: {
  useStore: typeof boundUseStore;
  useProp: typeof boundUseProp;
};
//#endregion
export { useScope as a, UseCacheValue as c, useStore as d, ScopeProvider as i, useCache as l, scopeMethods as n, cacheMethods as o, ScopeProps as r, UseCacheArray as s, storeMethods as t, UseStoreOptions as u };
//# sourceMappingURL=storeMethods-CK9-Q17H.d.ts.map