fusee-framework 1.6.0 → 1.8.0

package/framework/types/component.d.ts

@@ -1,88 +1,89 @@
-export type ComponentProps = Record<string, any>
-export type EmptyProps = Record<string, never>
-export type PropSchema = string[] | Record<string, PropConfig>
-
-export type PropConfig = {
-    type?: FunctionConstructor | StringConstructor | NumberConstructor | BooleanConstructor
-    default?: any | (() => any)
-    required?: boolean
-}
-
-export type EmitFn = (eventName: string, ...args: any[]) => void
-
-export type Slots = Record<string, string>
-
-export type SetupContext = {
-    emit: EmitFn
-    slots: Slots
-}
-
-export type ComponentInstance = {
-    props: ComponentProps
-    _mountHooks: (() => void)[]
-    _unmountHooks: (() => void)[]
-    _effects: import('./signal').EffectRunner[]
-    _element: HTMLElement | null
-    _provides: Record<string, any>
-    _parent: ComponentInstance | null
-}
-
-export type ComponentResult = {
-    template: string
-    [key: string]: any
-}
-
-export type ComponentOptions<TProps = ComponentProps, P = PropSchema> = {
-    props?: P
-    components?: Record<string, ComponentFactory<any>>
-    setup: (props: TProps, ctx: SetupContext) => ComponentResult
-}
-
-export type ComponentFactory<TProps = ComponentProps> = (
-    props?: TProps,
-    options?: { listeners?: Record<string, Function>, slots?: Slots, parent?: ComponentInstance }
-) => ComponentApi
-
-export type ComponentApi = {
-    render: (container: HTMLElement) => ComponentInstance
-    unmount: () => void
-    instance: ComponentInstance
-}
-
-export declare function onMount(fn: () => void): void
-export declare function onUnmount(fn: () => void): void
-export declare function parseSlots(slotHTML: string): Slots
-export declare function getCurrentInstance(): ComponentInstance | null
-
-export declare function provide<T>(key: string, value: T): void
-export declare function inject<T>(key: string): T | null
-
-type InferPropType<T> = T extends StringConstructor ? string :
-    T extends NumberConstructor ? number :
-    T extends BooleanConstructor ? boolean :
-    any;
-
-type InferProps<P> = P extends string[]
-    ? Record<P[number], any>
-    : P extends Record<string, PropConfig>
-    ? {
-        [K in keyof P]: P[K]['required'] extends true
-        ? InferPropType<P[K]['type']>
-        : InferPropType<P[K]['type']> | (P[K] extends { default: any } ? never : undefined)
-    }
-    : Record<string, any>;
-
-export declare function defineComponent<P extends PropSchema = any, TProps = InferProps<P>>(
-    options: ComponentOptions<TProps, P>
-): ComponentFactory<TProps>
-
-export type AsyncComponentLoader<TProps = ComponentProps> = () => Promise<ComponentFactory<TProps> | { default: ComponentFactory<TProps> } | Record<string, any>>
-
-export type AsyncComponentOptions<TProps = ComponentProps> = {
-    loader: AsyncComponentLoader<TProps>
-    loadingComponent?: ComponentFactory<any>
-}
-
-export declare function defineAsyncComponent<TProps = ComponentProps>(
-    loaderOrOptions: AsyncComponentLoader<TProps> | AsyncComponentOptions<TProps>
-): ComponentFactory<TProps>
+export type ComponentProps = Record<string, any>
+export type EmptyProps = Record<string, never>
+export type PropSchema = string[] | Record<string, PropConfig>
+
+export type PropConfig = {
+    type?: FunctionConstructor | StringConstructor | NumberConstructor | BooleanConstructor
+    default?: any | (() => any)
+    required?: boolean
+}
+
+export type EmitFn = (eventName: string, ...args: any[]) => void
+
+export type Slots = Record<string, string>
+
+export type SetupContext = {
+    emit: EmitFn
+    slots: Slots
+}
+
+export type ComponentInstance = {
+    props: ComponentProps
+    _mountHooks: (() => void)[]
+    _unmountHooks: (() => void)[]
+    _effects: import('./signal').EffectRunner[]
+    _element: HTMLElement | null
+    _parent: ComponentInstance | null
+    _injector: import('./di').Injector
+    _ownsInjector: boolean
+}
+
+export type ComponentResult = {
+    template: string
+    [key: string]: any
+}
+
+export type ComponentOptions<TProps = ComponentProps, P = PropSchema> = {
+    props?: P
+    components?: Record<string, ComponentFactory<any>>
+    setup: (props: TProps, ctx: SetupContext) => ComponentResult
+}
+
+export type ComponentFactory<TProps = ComponentProps> = (
+    props?: TProps,
+    options?: { listeners?: Record<string, Function>, slots?: Slots, parent?: ComponentInstance }
+) => ComponentApi
+
+export type ComponentApi = {
+    render: (container: HTMLElement) => ComponentInstance
+    unmount: () => void
+    instance: ComponentInstance
+}
+
+export declare function onMount(fn: () => void): void
+export declare function onUnmount(fn: () => void): void
+export declare function parseSlots(slotHTML: string): Slots
+export declare function getCurrentInstance(): ComponentInstance | null
+
+export declare function provide(keyOrProvider: any, value?: any): void
+export { inject } from './di'
+
+type InferPropType<T> = T extends StringConstructor ? string :
+    T extends NumberConstructor ? number :
+    T extends BooleanConstructor ? boolean :
+    any;
+
+type InferProps<P> = P extends string[]
+    ? Record<P[number], any>
+    : P extends Record<string, PropConfig>
+    ? {
+        [K in keyof P]: P[K]['required'] extends true
+        ? InferPropType<P[K]['type']>
+        : InferPropType<P[K]['type']> | (P[K] extends { default: any } ? never : undefined)
+    }
+    : Record<string, any>;
+
+export declare function defineComponent<P extends PropSchema = any, TProps = InferProps<P>>(
+    options: ComponentOptions<TProps, P>
+): ComponentFactory<TProps>
+
+export type AsyncComponentLoader<TProps = ComponentProps> = () => Promise<ComponentFactory<TProps> | { default: ComponentFactory<TProps> } | Record<string, any>>
+
+export type AsyncComponentOptions<TProps = ComponentProps> = {
+    loader: AsyncComponentLoader<TProps>
+    loadingComponent?: ComponentFactory<any>
+}
+
+export declare function defineAsyncComponent<TProps = ComponentProps>(
+    loaderOrOptions: AsyncComponentLoader<TProps> | AsyncComponentOptions<TProps>
+): ComponentFactory<TProps>

package/framework/types/di.d.ts

@@ -0,0 +1,43 @@
+export declare class InjectionToken<T = any> {
+    constructor(description: string);
+    description: string;
+    toString(): string;
+}
+
+export declare function isClass(fn: any): boolean;
+
+export interface InjectOptions {
+    optional?: boolean;
+    skipSelf?: boolean;
+    self?: boolean;
+}
+
+export declare abstract class Injector {
+    get<T>(token: any, options?: InjectOptions): T;
+}
+
+export declare class NullInjector extends Injector {
+    get<T>(token: any, options?: InjectOptions): T | null;
+}
+
+export declare type Provider = 
+  | any // class (shorthand)
+  | { provide: any, useClass: any }
+  | { provide: any, useValue: any }
+  | { provide: any, useFactory: () => any }
+  | { provide: any, useExisting: any };
+
+export declare class EnvironmentInjector extends Injector {
+    constructor(providers?: Provider[], parent?: Injector);
+    parent: Injector;
+    provide(provider: Provider): void;
+    get<T>(token: any, options?: InjectOptions): T;
+    createChild(providers?: Provider[]): EnvironmentInjector;
+    destroy(): void;
+}
+
+export declare function runInContext<T>(injector: Injector, fn: () => T): T;
+export declare function replaceActiveInjector(injector: Injector): void;
+export declare function inject<T>(token: any, options: InjectOptions & { optional: true }): T | null;
+export declare function inject<T>(token: any, options?: InjectOptions): T;
+

package/framework/types/event-delegation.d.ts

@@ -1,40 +1,13 @@
-// ─── Event Delegation Types ────────────────────────────────────────────────
-
-/**
- * Set of standard events that support delegation.
- * These events bubble and are commonly used in UI interactions.
- */
 export const DELEGATED_EVENTS: Set<string>
 
-/**
- * Check if an event type is delegated.
- * @param eventName - The event name to check (e.g., 'click', 'keydown')
- * @returns True if the event can be delegated
- */
 export function isDelegatedEvent(eventName: string): boolean
 
-/**
- * Options for registering a delegated event.
- */
 export interface DelegatedEventOptions {
-    /** Event modifiers (e.g., 'prevent', 'stop', 'debounce', 'throttle') */
     modifiers?: string[]
-    /** Component context for evaluating expressions */
     context?: Record<string, any>
-    /** Expression string to evaluate */
     expr?: string
 }
 
-/**
- * Register a delegated event handler for an element.
- * Creates a single document-level listener if not already present.
- *
- * @param element - The DOM element to register
- * @param eventType - The event type (e.g., 'click', 'input')
- * @param handler - The event handler function
- * @param options - Optional configuration
- * @returns Cleanup function to remove the handler
- */
 export function registerDelegatedEvent(
     element: Element,
     eventType: string,
@@ -42,16 +15,6 @@ export function registerDelegatedEvent(
     options?: DelegatedEventOptions
 ): () => void
 
-/**
- * Create a wrapped event handler with modifier support.
- * Supports: prevent, stop, self, debounce, throttle, keyboard modifiers.
- *
- * @param handler - The original handler (function or expression)
- * @param modifiers - Array of modifier names
- * @param context - Component context for evaluating expressions
- * @param expr - Expression string (when handler is a string)
- * @returns Wrapped handler function
- */
 export function createEventHandler(
     handler: Function | string,
     modifiers: string[],
@@ -59,29 +22,8 @@ export function createEventHandler(
     expr: string
 ): (event: Event) => void
 
-/**
- * Event handler syntax preference.
- * Use @ prefix for delegated events (optimized, single document listener).
- * Use on: prefix for native events (individual element listeners, full event control).
- *
- * @example
- * // Delegated - efficient for many elements
- * <button @click="handleClick">Click</button>
- *
- * @example
- * // Native - full control including stopPropagation
- * <button on:click="handleClick">Click</button>
- *
- * @example
- * // With modifiers
- * <form @submit.prevent="handleSubmit">Submit</form>
- * <input @keydown.enter="handleEnter" />
- * <input @input.debounce="handleInput" />
- */
 export interface EventHandlerSyntax {
-    /** Delegated event: @click, @input, @keydown, etc. */
     delegated: `@${string}`
-    /** Native event: on:click, on:input, on:custom, etc. */
     native: `on:${string}`
 }
 

package/framework/types/index.d.ts

@@ -1,22 +1,32 @@
-export * from './signal'
-export * from './component'
-export * from './composable'
-export * from './router'
-export * from './compiler'
-export * from './directives'
-export * from './store'
-export * from './event-delegation'
-
-declare global {
-    type Signal<T = any> = import('./signal').Signal<T>
-    type Computed<T = any> = import('./signal').Computed<T>
-    type SignalAccessor<T> = import('./signal').SignalAccessor<T>
-    type Composable<T extends (...args: any[]) => any> = import('./composable').Composable<T>
-    type DirectiveBinding<V = any> = import('./directives').DirectiveBinding<V>
-    type DirectiveHooks<V = any> = import('./directives').DirectiveHooks<V>
-    type DelegatedEventOptions = import('./event-delegation').DelegatedEventOptions
-    const defineStore: typeof import('./store').defineStore
-    const isDelegatedEvent: typeof import('./event-delegation').isDelegatedEvent
-}
-
-export as namespace Fusee
+export * from './signal'
+export * from './component'
+export * from './composable'
+export * from './router'
+export * from './compiler'
+export * from './directives'
+export * from './store'
+export * from './event-delegation'
+export * from './di'
+export * from './reconcile'
+
+declare global {
+    type Signal<T = any> = import('./signal').Signal<T>
+    type Computed<T = any> = import('./signal').Computed<T>
+    type SignalAccessor<T> = import('./signal').SignalAccessor<T>
+    type Composable<T extends (...args: any[]) => any> = import('./composable').Composable<T>
+    type DirectiveBinding<V = any> = import('./directives').DirectiveBinding<V>
+    type DirectiveHooks<V = any> = import('./directives').DirectiveHooks<V>
+    type DelegatedEventOptions = import('./event-delegation').DelegatedEventOptions
+    const defineStore: typeof import('./store').defineStore
+    const storeToRefs: typeof import('./store').storeToRefs
+    const storeToState: typeof import('./store').storeToState
+    const storeToGetters: typeof import('./store').storeToGetters
+    const useNestedStore: typeof import('./store').useNestedStore
+    type StoreHook<T> = import('./store').StoreHook<T>
+    const isDelegatedEvent: typeof import('./event-delegation').isDelegatedEvent
+    const InjectionToken: typeof import('./di').InjectionToken
+    const provideGlobal: typeof import('./di').provideGlobal
+    const reconcile: typeof import('./reconcile').reconcile
+}
+
+export as namespace Fusee

package/framework/types/reconcile.d.ts

@@ -0,0 +1,7 @@
+export function reconcile<T = any>(
+    container: Element,
+    oldList: T[],
+    newList: T[],
+    keyFn: (item: T) => any,
+    createFn: (item: T) => Element
+): void;

package/framework/types/router.d.ts

@@ -1,15 +1,42 @@
-import type { ComponentApi } from './component'
-
-export type Route = {
-    path: string
-    component: () => ComponentApi
-}
-
-export type Router = {
-    navigate: (path: string) => void
-    destroy: () => void
-}
-
-export declare function createRouter(routes: Route[]): Router
-export declare function navigate(path: string): void
-export declare function mountOutlet(el: HTMLElement): void
+import type { ComponentApi, ComponentFactory } from './component'
+import type { Signal } from './signal'
+
+export type Route = {
+    path: string | string[]
+    component: ComponentFactory<any>
+    children?: Route[]
+}
+
+export type ScrollPosition = { left: number; top: number } | { selector: string } | false
+
+export type ScrollBehaviorOptions = {
+    scrollToTop?: boolean
+    scrollToAnchor?: boolean
+    saveScrollPosition?: boolean
+    custom?: (to: string, from: string, savedPosition: ScrollPosition | null) => ScrollPosition | Promise<ScrollPosition>
+}
+
+export type Router = {
+    navigate: (path: string) => void
+    destroy: () => void
+}
+
+export type RouteParams = Record<string, string>
+
+export declare const currentRoute: Signal<string>
+export declare const routeParams: Signal<RouteParams>
+export declare const routeQuery: Signal<Record<string, string>>
+export declare const matchedRoutes: Signal<Route[]>
+
+export declare function createRouter(routes: Route[], options?: { cacheSize?: number; routerViewTimeout?: number; scrollBehavior?: ScrollBehaviorOptions }): Router
+export declare function navigate(path: string): void
+export declare function mountOutlet(el: HTMLElement): void
+
+export type FileRouterOptions = {
+    loadingComponent?: ComponentFactory<any>
+}
+
+export declare function generateRoutes(
+    globResults: Record<string, () => Promise<any>>,
+    options?: FileRouterOptions
+): Route[]

package/framework/types/signal.d.ts

@@ -1,78 +1,147 @@
-export type SignalAccessor<T> = {
-    (): T;
-    (newValue: T): void;
-    isSignal: boolean;
-}
-
-export interface ReactiveArrayMethods<T> {
-    map<U>(callbackfn: (value: T, index: number, array: T[]) => U): Computed<U[]>;
-    filter(predicate: (value: T, index: number, array: T[]) => boolean): Computed<T[]>;
-    slice(start?: number, end?: number): Computed<T[]>;
-    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): Computed<U>;
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): Computed<T>;
-    find(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
-    findLast(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
-    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
-    findLastIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
-    every(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
-    some(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
-    includes(searchElement: T, fromIndex?: number): Computed<boolean>;
-    indexOf(searchElement: T, fromIndex?: number): Computed<number>;
-    lastIndexOf(searchElement: T, fromIndex?: number): Computed<number>;
-    at(index: number): Computed<T | undefined>;
-    concat(...items: (T | T[])[]): Computed<T[]>;
-    flat<depth extends number = 1>(depth?: depth): Computed<any[]>;
-    flatMap<U>(callback: (value: T, index: number, array: T[]) => U | U[]): Computed<U[]>;
-    join(separator?: string): Computed<string>;
-}
-
-export type ArraySignalAccessor<T extends any[]> = SignalAccessor<T> & ReactiveArrayMethods<T[number]> & {
-    push(...items: T[number][]): number;
-    pop(): T[number] | undefined;
-    shift(): T[number] | undefined;
-    unshift(...items: T[number][]): number;
-    splice(start: number, deleteCount: number, ...items: T[number][]): T[number][];
-    remove(predicate: (item: T[number], index: number) => boolean): void;
-    clear(): void;
-    sort(compareFn?: (a: T[number], b: T[number]) => number): ArraySignalAccessor<T>;
-    reverse(): ArraySignalAccessor<T>;
-}
-
-export type ComputedAccessor<T> = {
-    (): T;
-    isSignal: boolean;
-    readonly: true;
-} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-
-export type Signal<T = any> = SignalAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-export type Computed<T = any> = ComputedAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
-
-type EffectRunner = {
-    (): void;
-    deps: Set<Set<EffectRunner>>;
-}
-
-export type WatchSource<T = any> = (() => T) | Signal<T> | Computed<T>
-export type WatchCallback<T = any> = (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void
-
-export interface WatchOptions {
-    immediate?: boolean;
-    equals?: (a: any, b: any) => boolean;
-}
-
-export declare function signal<T extends any[]>(initialValue: T): ArraySignalAccessor<T>
-export declare function signal<T>(initialValue: T): SignalAccessor<T>
-export declare function effect(fn: () => void): () => void
-export declare function computed<T>(fn: () => T): Computed<T>
-export declare function batch<T>(fn: () => T): T
-export declare function untrack<T>(fn: () => T): T
-export declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void
-export declare function watch<T extends any[]>(
-    sources: [...{ [K in keyof T]: WatchSource<T[K]> }],
-    callback: (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void,
-    options?: WatchOptions
-): () => void
-export declare function inspect(...args: any[]): (() => void) | void
-
-declare function setEffectHook(fn: (eff: any) => void): void
-
+export type SignalAccessor<T> = {
+    (): T;
+    (newValue: T): void;
+    isSignal: boolean;
+}
+
+export interface ReactiveArrayMethods<T> {
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U): Computed<U[]>;
+    filter(predicate: (value: T, index: number, array: T[]) => boolean): Computed<T[]>;
+    slice(start?: number, end?: number): Computed<T[]>;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): Computed<U>;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): Computed<T>;
+    find(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
+    findLast(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<T | undefined>;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
+    findLastIndex(predicate: (value: T, index: number, obj: T[]) => boolean): Computed<number>;
+    every(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
+    some(predicate: (value: T, index: number, array: T[]) => boolean): Computed<boolean>;
+    includes(searchElement: T, fromIndex?: number): Computed<boolean>;
+    indexOf(searchElement: T, fromIndex?: number): Computed<number>;
+    lastIndexOf(searchElement: T, fromIndex?: number): Computed<number>;
+    at(index: number): Computed<T | undefined>;
+    concat(...items: (T | T[])[]): Computed<T[]>;
+    flat<depth extends number = 1>(depth?: depth): Computed<any[]>;
+    flatMap<U>(callback: (value: T, index: number, array: T[]) => U | U[]): Computed<U[]>;
+    join(separator?: string): Computed<string>;
+}
+
+export type ArraySignalAccessor<T extends any[]> = SignalAccessor<T> & ReactiveArrayMethods<T[number]> & {
+    push(...items: T[number][]): number;
+    pop(): T[number] | undefined;
+    shift(): T[number] | undefined;
+    unshift(...items: T[number][]): number;
+    splice(start: number, deleteCount: number, ...items: T[number][]): T[number][];
+    remove(predicate: (item: T[number], index: number) => boolean): void;
+    clear(): void;
+    sort(compareFn?: (a: T[number], b: T[number]) => number): ArraySignalAccessor<T>;
+    reverse(): ArraySignalAccessor<T>;
+}
+
+export type ComputedAccessor<T> = {
+    (): T;
+    isSignal: boolean;
+    readonly: true;
+} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+export type Signal<T = any> = SignalAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+export type Computed<T = any> = ComputedAccessor<T> & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+type EffectRunner = {
+    (): void;
+    deps: Set<Set<EffectRunner>>;
+}
+
+export type WatchSource<T = any> = (() => T) | Signal<T> | Computed<T>
+export type WatchCallback<T = any> = (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void
+
+export interface WatchOptions {
+    immediate?: boolean;
+    equals?: (a: any, b: any) => boolean;
+}
+
+export interface ResourceOptions {
+    staleTime?: number;
+    key?: string | number;
+}
+
+export type ResourceAccessor<T> = {
+    (): T | undefined;
+    read(): T;
+    isSignal: boolean;
+    loading: Signal<boolean>;
+    isFetching: Signal<boolean>;
+    error: Signal<any>;
+} & (T extends any[] ? ReactiveArrayMethods<T[number]> : {})
+
+export type ResourceActions<T> = {
+    mutate: (val: T) => void;
+    refetch: () => void;
+}
+
+export type ResourceReturn<T, R = unknown> = [
+    ResourceAccessor<T>,
+    {
+        mutate: (val: T) => void;
+        refetch: () => void;
+    }
+];
+
+export interface SuspenseOptions {
+    onError?: (err: any) => void;
+}
+
+export interface SuspenseSignal<T> {
+    (): T;
+    pending: Signal<boolean>;
+    error: Signal<any>;
+}
+
+export type Resource<T> = [ResourceAccessor<T>, ResourceActions<T>]
+
+export declare function signal<T extends any[]>(initialValue: T): ArraySignalAccessor<T>
+export declare function signal<T>(initialValue: T): SignalAccessor<T>
+export declare function effect(fn: () => void): () => void
+export declare function computed<T>(fn: () => T): Computed<T>
+export declare function batch<T>(fn: () => T): T
+export declare function untrack<T>(fn: () => T): T
+export declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void
+export declare function watch<T extends any[]>(
+    sources: [...{ [K in keyof T]: WatchSource<T[K]> }],
+    callback: (newValue: T, oldValue: T | undefined, onCleanup: (fn: () => void) => void) => void,
+    options?: WatchOptions
+): () => void
+export declare function inspect(...args: any[]): (() => void) | void
+export declare function onCleanup(fn: () => void): void
+
+export function resource<T, R = any>(
+    fetcher: (input: R) => Promise<T>,
+    options?: { key?: string | number; staleTime?: number }
+): ResourceReturn<T, R>;
+
+export function resource<T, R>(
+    source: () => R,
+    fetcher: (input: R) => Promise<T>,
+    options?: { key?: string | number; staleTime?: number }
+): ResourceReturn<T, R>;
+
+export function createSuspense<T>(
+    renderFn: () => T,
+    fallbackFn: (() => T) | T,
+    options?: SuspenseOptions
+): [SuspenseSignal<T>, () => void];
+
+declare function setEffectHook(fn: (eff: any) => void): void
+
+export type AsyncPriority = 'high' | 'low';
+export interface AsyncJobOptions {
+    priority?: AsyncPriority;
+}
+
+export function scheduleAsyncJob(fn: () => void, opts?: AsyncJobOptions): void;
+
+export interface ResourceOptions<T = any> {
+    key?: string | number;
+    staleTime?: number;
+    fetchPriority?: AsyncPriority;
+}