/// <reference types="react-sweet-state" />
import type { RouterContext } from '../../../index';
import type { ResourceStoreContext, ResourceStoreData, RouteResource, RouteResourceResponse, RouteResourceUpdater } from '../../common/types';
import { ContainerProps, GetResourceOptions, ResourceAction, ResourceSliceIdentifier, State } from './types';
export { createResource, ResourceDependencyError } from './utils';
export type { CreateResourceArgAsync, CreateResourceArgBase, CreateResourceArgSync, } from './utils';
export declare const privateActions: {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     */
    clearResource: (resource: RouteResource, routerStoreContext: RouterContext | null) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse<unknown>>>;
    /**
     * Prefetch a single resource and store in the prefetch cache.
     */
    prefetchResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>>;
};
export declare const actions: {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
};
export type Actions = typeof actions;
export declare const ResourceStore: import("react-sweet-state").Store<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>;
export declare const ResourceContainer: import("react-sweet-state").ContainerComponent<ContainerProps>;
export declare const ResourceSubscriber: import("react-sweet-state").SubscriberComponent<RouteResourceResponse, import("react-sweet-state").BoundActions<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>, {
    resourceType: string;
    resourceKey: string;
}>;
export declare const getResourceStore: () => import("react-sweet-state").StoreInstance<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>;
export declare const useResourceStore: import("react-sweet-state").HookFunction<RouteResourceResponse, import("react-sweet-state").BoundActions<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>, ResourceSliceIdentifier>;
export declare const useResourceStoreActions: import("react-sweet-state").HookActionsFunction<import("react-sweet-state").BoundActions<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>>;
export declare const useResourceStoreContext: import("react-sweet-state").HookFunction<ResourceStoreContext, import("react-sweet-state").BoundActions<State, {
    /**
     * Clears a resource for the current key, or where context is not provided all keys.
     * Execute such that dependencies on current route will be cleared.
     */
    clearResource: (resource: RouteResource, routerStoreContext?: RouterContext) => ResourceAction<void>;
    /**
     * Update the data property for a resource in the cache and reset expiresAt based
     * on maxAge.
     * Execute such that dependencies on current route will be updated.
     */
    updateResourceState: (resource: RouteResource, routerStoreContext: RouterContext, getNewSliceData: RouteResourceUpdater) => ResourceAction<void>;
    /**
     * Get a single resource, either from the cache if it exists and has not expired, or
     * the remote if it has expired.
     * Execute such that dependencies on current route will be updated.
     */
    getResource: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request a single resource and update the resource cache.
     * Execute such that dependencies on current route will be updated.
     */
    getResourceFromRemote: (resource: RouteResource, routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>>;
    /**
     * Request all resources.
     */
    requestAllResources: (routerStoreContext: RouterContext, options?: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse[]>>;
    /**
     * Cleans expired resources and resets them back to their initial state.
     * We need to do this when transitioning into a route.
     */
    cleanExpiredResources: (resources: RouteResource[], routerStoreContext: RouterContext) => ResourceAction<void>;
    /**
     * Requests a specific set of resources.
     */
    requestResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<RouteResourceResponse>[]>;
    /**
     * Prefetch a specific set of resources.
     */
    prefetchResources: (resources: RouteResource[], routerStoreContext: RouterContext, options: GetResourceOptions) => ResourceAction<Promise<void>[]>;
    /**
     * Hydrates the store with state.
     * Will not override pre-hydrated state.
     */
    hydrate: ({ resourceData, resourceContext, }: {
        resourceData?: ResourceStoreData | undefined;
        resourceContext?: ResourceStoreContext | undefined;
    }) => ResourceAction<void>;
    /**
     * Gets the store's context
     */
    getContext: () => ResourceAction<ResourceStoreContext>;
    /**
     * Returns safe, portable and rehydratable data.
     */
    getSafeData: () => ResourceAction<ResourceStoreData>;
}>, void>;