declare const ContextWithDefaultSymbol: unique symbol;
type ArrayMaybe<T = unknown> = T[] | T;
type Callback = () => void;
type Child = null | undefined | boolean | bigint | number | string | symbol | Node | Array<Child> | (() => Child);
type ChildWithMetadata<T = unknown> = (() => Child) & {
    metadata: T;
};
type Classes = FunctionMaybe<null | undefined | string | Record<string, FunctionMaybe<null | undefined | boolean>> | (FunctionMaybe<null | undefined | boolean | string> | Classes)[]>;
type ComponentFunction<P = {}> = (props: P) => Child;
type ComponentIntrinsicElement = keyof JSX.IntrinsicElements;
type ComponentNode = Node;
type Component<P = {}> = ComponentFunction<P> | ComponentIntrinsicElement | ComponentNode;
type ComponentsMap = Record<string, ComponentFunction<any>>;
type Constructor<T = unknown> = {
    new (): T;
};
type ConstructorWith<T = unknown, Arguments extends unknown[] = []> = {
    new (...args: Arguments): T;
};
type ContextData<T = unknown> = {
    symbol: symbol;
    defaultValue?: T;
};
type ContextProvider<T = unknown> = (props: {
    value: T;
    children: Child;
}) => Child;
type Context<T = unknown> = {
    Provider: ContextProvider<T>;
};
type ContextWithDefault<T = unknown> = Context<T> & {
    readonly [ContextWithDefaultSymbol]: true;
};
type DirectiveFunction<Arguments extends unknown[] = []> = (ref: globalThis.Element, ...args: Arguments) => void;
type DirectiveProvider = (props: {
    children: Child;
}) => Child;
type DirectiveRef<Arguments extends unknown[] = []> = (...args: Arguments) => ((ref: globalThis.Element) => void);
type DirectiveRegister = () => void;
type Directive<Arguments extends unknown[] = []> = {
    Provider: DirectiveProvider;
    ref: DirectiveRef<Arguments>;
    register: DirectiveRegister;
};
type DirectiveData<Arguments extends unknown[] = []> = {
    fn: DirectiveFunction<Arguments>;
    immediate: boolean;
};
type DirectiveOptions = {
    immediate?: boolean;
};
type Disposer = () => void;
type EffectFunction = () => Disposer | void;
type EffectOptions = import('oby').EffectOptions;
type Element<T = Child> = () => T;
type ExtractArray<T> = Extract<T, unknown[]>;
type EventListener = (event: Event) => void;
type Falsy<T = unknown> = Extract<T, 0 | -0 | 0n | -0n | '' | false | null | undefined | void>;
type ForOptions = import('oby').ForOptions;
type FN<Arguments extends unknown[], Return extends unknown = void> = (...args: Arguments) => Return;
type FragmentUndefined = {
    placeholder?: Node;
    values: undefined;
    fragmented?: false;
    length: 0;
};
type FragmentNode = {
    placeholder?: Node;
    values: Node;
    fragmented?: false;
    length: 1;
};
type FragmentFragment = {
    placeholder?: Node;
    values: Fragment;
    fragmented: true;
    length: 1;
};
type FragmentNodes = {
    placeholder?: Node;
    values: Node[];
    fragmented?: false;
    length: 2 | 3 | 4 | 5;
};
type FragmentFragments = {
    placeholder?: Node;
    values: Fragment[];
    fragmented: true;
    length: 2 | 3 | 4 | 5;
};
type FragmentMixed = {
    placeholder?: Node;
    values: (Node | Fragment)[];
    fragmented: true;
    length: 2 | 3 | 4 | 5;
};
type Fragment = FragmentUndefined | FragmentNode | FragmentFragment | FragmentNodes | FragmentFragments | FragmentMixed;
type FunctionMaybe<T = unknown> = (() => T) | T;
type Indexed<T = unknown> = T extends ObservableReadonly<infer U> ? ObservableReadonly<U> : ObservableReadonly<T>;
type LazyComponent<P = {}> = (props: P) => ObservableReadonly<Child>;
type LazyFetcher<P = {}> = () => Promise<{
    default: ComponentFunction<P>;
} | ComponentFunction<P>>;
type LazyResult<P = {}> = LazyComponent<P> & ({
    preload: () => Promise<void>;
});
type MemoOptions<T = unknown> = import('oby').MemoOptions<T>;
type Observable<T = unknown> = import('oby').Observable<T>;
type ObservableLike<T = unknown> = import('oby').ObservableLike<T>;
type ObservableReadonly<T = unknown> = import('oby').ObservableReadonly<T>;
type ObservableReadonlyLike<T = unknown> = import('oby').ObservableReadonlyLike<T>;
type ObservableMaybe<T = unknown> = Observable<T> | ObservableReadonly<T> | T;
type ObservableOptions<T = unknown> = import('oby').ObservableOptions<T>;
type PromiseMaybe<T = unknown> = Promise<T> | T;
type Props = Record<string, any>;
type Ref<T = unknown> = (value: T) => void;
type ResourceStaticPending<T = unknown> = {
    pending: true;
    error?: never;
    value?: never;
    latest?: T;
};
type ResourceStaticRejected = {
    pending: false;
    error: Error;
    value?: never;
    latest?: never;
};
type ResourceStaticResolved<T = unknown> = {
    pending: false;
    error?: never;
    value: T;
    latest: T;
};
type ResourceStatic<T = unknown> = ResourceStaticPending<T> | ResourceStaticRejected | ResourceStaticResolved<T>;
type ResourceFunction<T = unknown> = {
    pending(): boolean;
    error(): Error | undefined;
    value(): T | undefined;
    latest(): T | undefined;
};
type Resource<T = unknown> = ObservableReadonly<ResourceStatic<T>> & ResourceFunction<T>;
type StoreOptions = import('oby').StoreOptions;
type Styles = FunctionMaybe<null | undefined | string | Record<string, FunctionMaybe<null | undefined | number | string>> | (FunctionMaybe<null | undefined | number | string> | Styles)[]>;
type SuspenseCollectorData = {
    active: Observable<boolean>;
    register: (suspense: SuspenseData) => void;
    unregister: (suspense: SuspenseData) => void;
};
type SuspenseData = {
    active: Observable<boolean>;
    increment: (nr?: number) => void;
    decrement: (nr?: number) => void;
};
type TemplateActionPath = number[];
type TemplateActionProxy = (target: Node, method: string, key?: string, targetNode?: Node) => void;
type TemplateActionWithNodes = [Node, string, string, string?, Node?];
type TemplateActionWithPaths = [TemplateActionPath, string, string, string?, TemplateActionPath?];
type TemplateVariableProperties = string[];
type TemplateVariableData = {
    path: TemplateActionPath;
    properties: TemplateVariableProperties;
};
type TemplateVariablesMap = Map<TemplateActionPath, string>;
type Truthy<T = unknown> = Exclude<T, 0 | -0 | 0n | -0n | '' | false | null | undefined | void>;
export type { ArrayMaybe, Callback, Child, ChildWithMetadata, Classes, ComponentFunction, ComponentIntrinsicElement, ComponentNode, Component, ComponentsMap, Constructor, ConstructorWith, ContextData, ContextProvider, Context, ContextWithDefault, DirectiveFunction, DirectiveProvider, DirectiveRef, DirectiveRegister, Directive, DirectiveData, DirectiveOptions, Disposer, EffectFunction, EffectOptions, Element, ExtractArray, EventListener, Falsy, ForOptions, FN, FragmentUndefined, FragmentNode, FragmentFragment, FragmentNodes, FragmentFragments, FragmentMixed, Fragment, FunctionMaybe, Indexed, LazyComponent, LazyFetcher, LazyResult, MemoOptions, Observable, ObservableLike, ObservableReadonly, ObservableReadonlyLike, ObservableMaybe, ObservableOptions, PromiseMaybe, Props, Ref, ResourceStaticPending, ResourceStaticRejected, ResourceStaticResolved, ResourceStatic, ResourceFunction, Resource, StoreOptions, Styles, SuspenseCollectorData, SuspenseData, TemplateActionPath, TemplateActionProxy, TemplateActionWithNodes, TemplateActionWithPaths, TemplateVariableProperties, TemplateVariableData, TemplateVariablesMap, Truthy };