import React, { type ComponentType, type ReactElement } from 'react';
import { type StyleProp, type ViewStyle } from 'react-native';
export type ThreadedComponent<Props extends object = Record<string, never>> = ComponentType<Props> & {
    __threadedRuntime: {
        name: string;
    };
};
export type ThreadedHeadlessTaskContext<Payload> = {
    payload: Payload;
    runtimeName: ThreadedRuntimeName;
    taskName: string;
};
export type ThreadedHeadlessTask<Payload = unknown> = (context: ThreadedHeadlessTaskContext<Payload>) => void | Promise<void>;
export declare const MAIN_RUNTIME_NAME = "main";
export type CurrentRuntimeInfo = {
    isMain: boolean;
    name: string;
    kind: string | null;
};
export declare function getCurrentRuntime(): CurrentRuntimeInfo;
export declare function getCurrentRuntimeName(): string;
export declare function isMainRuntime(): boolean;
export type ThreadedRuntimeName = string;
export type ThreadedRuntimePrewarmOptions = {
    kind?: string;
    useMainNativeModules?: boolean;
};
export type ThreadedHeadlessTaskOptions<Payload = unknown> = {
    payload?: Payload;
    runtimeName?: ThreadedRuntimeName;
};
type AnyFunction = (...args: any[]) => any;
export type RuntimeFunctionMetadata = {
    id: string;
};
export type RuntimeFunction<TFunction extends AnyFunction> = TFunction & {
    __runtimeFunction?: RuntimeFunctionMetadata;
    runOn(runtimeName: ThreadedRuntimeName, ...args: Parameters<TFunction>): Promise<Awaited<ReturnType<TFunction>>>;
};
export type RuntimeFunctionCallBuilder<TFunction extends AnyFunction> = {
    on(runtimeName: ThreadedRuntimeName): (...args: Parameters<TFunction>) => Promise<Awaited<ReturnType<TFunction>>>;
};
export type RuntimeFunctionFactory = {
    <TFunction extends AnyFunction>(fn: TFunction): RuntimeFunction<TFunction>;
    withId<TFunction extends AnyFunction>(id: string, fn: TFunction): RuntimeFunction<TFunction>;
    named<TFunction extends AnyFunction>(id: string, fn: TFunction): RuntimeFunction<TFunction>;
};
export type ThreadedProps<Props extends object = Record<string, never>> = {
    accessibilityLabel?: string;
    component: ThreadedComponent<Props>;
    props?: Props;
    runtimeName?: ThreadedRuntimeName;
    style?: StyleProp<ViewStyle>;
    surfaceKey?: string;
    testID?: string;
};
export type ThreadedScreenProps<Props extends object = Record<string, never>> = ThreadedProps<Props> & {
    destroyOnUnmount?: boolean;
    preload?: boolean;
};
export type OnRuntimeProps<Props extends object = Record<string, never>> = {
    accessibilityLabel?: string;
    children: ReactElement<Props>;
    name: ThreadedRuntimeName;
    style?: StyleProp<ViewStyle>;
    surfaceKey?: string;
    testID?: string;
};
export type ThreadedReactSurfaceProps<Props extends object = Record<string, never>> = {
    componentName: string;
    initialProps?: Props;
    runtimeName?: ThreadedRuntimeName;
    surfaceKey?: string;
    style?: StyleProp<ViewStyle>;
    testID?: string;
    accessibilityLabel?: string;
};
export declare function registerThreadedComponent<Props extends object>(name: string, component: ComponentType<Props>): void;
export declare function registerLazyThreadedComponent<Props extends object>(name: string, loadComponent: () => ComponentType<Props>): void;
export declare function registerThreadedHeadlessTask<Payload = unknown>(name: string, task: ThreadedHeadlessTask<Payload>): void;
export declare function registerRuntimeFunction<TFunction extends AnyFunction>(id: string, loadFunction: () => RuntimeFunction<TFunction>): void;
export declare const runtimeFunction: RuntimeFunctionFactory;
export declare function call<TFunction extends AnyFunction>(fn: RuntimeFunction<TFunction>): RuntimeFunctionCallBuilder<TFunction>;
export declare function usingRuntime(runtimeName: ThreadedRuntimeName): {
    run<TValue>(_callback: () => TValue): Promise<Awaited<TValue>>;
};
export declare function threadedComponent<Props extends object>(name: string, component: ComponentType<Props>): ThreadedComponent<Props>;
export declare function Threaded<Props extends object>({ accessibilityLabel, component, props, runtimeName, style, surfaceKey, testID, }: ThreadedProps<Props>): React.JSX.Element;
export declare function OnRuntime<Props extends object>({ accessibilityLabel, children, name, style, surfaceKey, testID, }: OnRuntimeProps<Props>): React.JSX.Element | null;
export declare function ThreadedScreen<Props extends object>({ accessibilityLabel, component, destroyOnUnmount, preload, props, runtimeName, style, surfaceKey, testID, }: ThreadedScreenProps<Props>): React.JSX.Element;
export declare function ThreadedReactSurface<Props extends object>({ accessibilityLabel, componentName, initialProps, runtimeName, style, surfaceKey, testID, }: ThreadedReactSurfaceProps<Props>): React.JSX.Element;
export declare function ThreadedRuntimeHost({ componentName, initialPropsJson, runtimeName, }: {
    componentName?: string;
    initialPropsJson?: string;
    runtimeName?: string;
}): ReactElement | null;
export declare const ThreadedRuntime: {
    defaultRuntimeName: string;
    defaultBusinessRuntimeName: string;
    preload(runtimeName?: ThreadedRuntimeName, options?: ThreadedRuntimePrewarmOptions): Promise<void>;
    prewarm(runtimeName?: ThreadedRuntimeName, options?: ThreadedRuntimePrewarmOptions): Promise<void>;
    prewarmBusinessRuntime(runtimeName?: ThreadedRuntimeName): Promise<void>;
    runHeadlessTask<Payload = unknown>(taskName: string, options?: ThreadedHeadlessTaskOptions<Payload>): Promise<void>;
    run<TFunction extends AnyFunction>(runtimeName: ThreadedRuntimeName, fn: RuntimeFunction<TFunction>, ...args: Parameters<TFunction>): Promise<Awaited<ReturnType<TFunction>>>;
    call<TFunction extends AnyFunction>(runtimeName: ThreadedRuntimeName, fn: RuntimeFunction<TFunction>, ...args: Parameters<TFunction>): Promise<Awaited<ReturnType<TFunction>>>;
    runtime(runtimeName: ThreadedRuntimeName): {
        run<TFunction extends AnyFunction>(fn: RuntimeFunction<TFunction>, ...args: Parameters<TFunction>): Promise<Awaited<ReturnType<TFunction>>>;
    };
    destroy(runtimeName?: ThreadedRuntimeName): Promise<void>;
    destroyAll(): Promise<void>;
    getRuntimeNames(): Promise<string[]>;
};
export {};
//# sourceMappingURL=ThreadedRuntime.d.ts.map