import type { FragmentVNode, FragmentVNodeWithChildren, MarshalledVNode, SourceReferenceVNode, VNode } from "./vnode";
import type { SourceReference } from "./source-reference";
import type { Fragment } from "./fragment";
declare type GetLength<T extends unknown[]> = T extends {
    length: infer L;
} ? L : never;
/**
 * @experimental This may go away
 */
export declare const Instance: unique symbol;
/**
 * @experimental This may not be available all the time, and this functionality may disappear.
 */
export declare const ChildrenSource: unique symbol;
/**
 * @experimental This may not be available all the time, and this functionality may disappear.
 */
export declare const ChildrenSourceFunction: unique symbol;
export declare type CreateNodeChildrenWithSourceType<C extends unknown[], N extends VNode[] = VNode[]> = AsyncIterable<N> & {
    /**
     * @experimental This may not be available all the time, and this functionality may disappear.
     */
    [ChildrenSource]?: C;
};
declare type IfChildren<C extends unknown[], Z, K = never> = 0 extends GetLength<C> ? K : C extends never[] ? K : Z;
export declare type CreateNodeChildren<C extends unknown[], N extends VNode[] = VNode[]> = IfChildren<C, CreateNodeChildrenWithSourceType<C, N>>;
declare type Options = Record<string, unknown> | object | undefined;
declare type MaxDepth = 8;
declare type CreateNodeResultCoreOp1<T extends CreateNodeOp1Function, O extends Options = Options, C extends unknown[] = [], Depth extends number = MaxDepth> = Omit<FragmentVNode, "source" | "children"> & {
    source: T;
    children: CreateNodeChildrenWithSourceType<T[], ChildrenResult<ReturnType<T>>[]>;
};
declare type CreateNodeResultCoreOp2<T extends CreateNodeOp2Promise, O extends Options = Options, C extends unknown[] = [], Depth extends number = MaxDepth> = Omit<FragmentVNode, "source" | "children"> & {
    source: T;
    children: CreateNodeChildrenWithSourceType<T[], ChildrenResult<T>[]>;
};
declare type CreateNodeResultCoreOp3<T extends CreateNodeOp3Fragment, O extends Options = Options, C extends unknown[] = [], Depth extends number = MaxDepth> = CreateNodeResult<FragmentVNode, O, C>;
declare type CreateNodeResultCoreOp4<T extends CreateNodeOp4VNode, O extends Options, C extends unknown[], Depth extends number = MaxDepth> = Omit<T, "children"> & {
    options: T["options"] extends O ? O : T["options"] & O;
    children: T["children"] extends AsyncIterable<unknown> ? T["children"] : CreateNodeChildren<C, ChildrenResult<C>[]>;
};
declare type CreateNodeResultCoreOp5<T extends CreateNodeOp5MarshalledVNode, O extends Options = Options, C extends unknown[] = [], Depth extends number = MaxDepth> = VNode;
declare type CreateNodeResultCoreOp6<T extends CreateNodeOp6SourceReference, O extends Options, C extends unknown[] = [], Depth extends number = MaxDepth> = Omit<VNode, "source" | "scalar" | "children"> & {
    source: T;
    scalar: IfChildren<C, false, true>;
    options: O;
    children: CreateNodeChildren<C, ChildrenResult<C>[]>;
};
declare type CreateNodeResultCoreOp7<T extends CreateNodeOp7IterableIterator, O extends Options, C extends unknown[], Depth extends number = MaxDepth> = Omit<FragmentVNodeWithChildren, "options"> & {
    options: O;
};
declare type CreateNodeResultCoreOp8<T extends CreateNodeOp8Iterable, O extends Options, C extends unknown[], Depth extends number = MaxDepth> = Omit<FragmentVNodeWithChildren, "options"> & {
    options: O;
    children: T extends AsyncIterable<infer I> ? AsyncIterable<ChildrenResult<I>[]> : T extends Iterable<infer I> ? AsyncIterable<ChildrenResult<I>[]> : never;
};
declare type CreateNodeResultCoreOp9<T extends CreateNodeOp9Falsy, O extends Options, C extends unknown[], Depth extends number = MaxDepth> = Omit<FragmentVNode, "source"> & {
    source: undefined;
};
/**
 * @experimental
 */
export declare type CreateNodeResultCore<T, O extends Options = Options, C extends unknown[] = [], Depth extends number = MaxDepth> = T extends CreateNodeOp1Function ? CreateNodeResultCoreOp1<T, O, C, Depth> : T extends CreateNodeOp2Promise ? CreateNodeResultCoreOp2<T, O, C, Depth> : T extends CreateNodeOp3Fragment ? CreateNodeResultCoreOp3<T, O, C, Depth> : T extends CreateNodeOp4VNode ? CreateNodeResultCoreOp4<T, O, C, Depth> : T extends CreateNodeOp5MarshalledVNode ? CreateNodeResultCoreOp5<T, O, C, Depth> : T extends CreateNodeOp6SourceReference ? CreateNodeResultCoreOp6<T, O, C, Depth> : T extends CreateNodeOp7IterableIterator ? CreateNodeResultCoreOp7<T, O, C, Depth> : T extends CreateNodeOp8Iterable ? CreateNodeResultCoreOp8<T, O, C, Depth> : T extends CreateNodeOp9Falsy ? CreateNodeResultCoreOp9<T, O, C, Depth> : T extends CreateNodeOp9000ExplicitExceptionCaseForObject ? never : never;
/**
 * @experimental
 */
export declare type CreateNodeResult<T, O extends Options = Options, C extends unknown[] = []> = VNode & CreateNodeResultCore<T, O, C>;
export interface CreateNodeOp1Function<T = unknown> {
    (options?: unknown, children?: VNode): T;
}
export declare type CreateNodeOp2Promise = Promise<unknown>;
export declare type CreateNodeOp3Fragment = typeof Fragment;
export declare type CreateNodeOp4VNode = VNode;
export declare type CreateNodeOp5MarshalledVNode = MarshalledVNode;
export declare type CreateNodeOp6SourceReference = SourceReference;
export declare type CreateNodeOp7IterableIterator = IterableIterator<unknown> | AsyncIterableIterator<unknown>;
export declare type CreateNodeOp8Iterable = Iterable<unknown> | AsyncIterable<unknown>;
export declare type CreateNodeOp9Falsy = undefined | null;
export declare type CreateNodeOp9000ExplicitExceptionCaseForObject = object;
export declare type Source = CreateNodeOp1Function | CreateNodeOp2Promise | CreateNodeOp3Fragment | CreateNodeOp4VNode | CreateNodeOp5MarshalledVNode | CreateNodeOp6SourceReference | CreateNodeOp7IterableIterator | CreateNodeOp8Iterable | CreateNodeOp9Falsy | CreateNodeOp9000ExplicitExceptionCaseForObject;
interface VNodeWithChildrenSourceType<C extends unknown[], N extends VNode[]> {
    children: CreateNodeChildrenWithSourceType<C>;
}
export declare type InferChildrenSource<V extends {
    children: AsyncIterable<unknown>;
}> = V extends VNodeWithChildrenSourceType<infer C, VNode[]> ? C : [];
declare type ChildrenResult<CValue> = CValue extends ChildrenOp1Undefined ? never : CValue extends ChildrenOp2Fragment ? undefined extends CValue["children"] ? never : CValue["children"] extends AsyncIterable<Iterable<infer R>> ? ChildrenResult<R> : never : CValue extends ChildrenOp3VNode ? CValue : CValue extends ChildrenOp4SourceReference ? SourceReferenceVNode<CValue> : CValue extends ChildrenOp5IterableIterator ? CValue extends IterableIterator<infer R> ? ChildrenResult<R> : never : CValue extends ChildrenOp6Promise ? CValue extends Promise<infer R> ? ChildrenResult<R> : never : CValue extends ChildrenOp7Iterable ? CValue extends Iterable<infer R> ? ChildrenResult<R> : CValue extends AsyncIterable<infer R> ? ChildrenResult<R> : never : never;
export declare type VNodeChildrenFromSource<V extends {
    children?: AsyncIterable<VNode[]>;
}> = VNodeWithChildrenFromSource<V>["children"];
/**
 * @experimental This type may be removed
 */
export declare type VNodeWithChildrenFromSource<V extends {
    children?: AsyncIterable<VNode[]>;
}> = Omit<V, "children"> & {
    children: V extends {
        children: AsyncIterable<infer Z>;
    } ? Z extends VNode ? CreateNodeChildrenWithSourceType<InferChildrenSource<V>, Z[]> : never : never;
};
declare type ChildrenOp1Undefined = undefined;
declare type ChildrenOp2Fragment = FragmentVNode;
declare type ChildrenOp3VNode = {
    reference: SourceReference;
};
declare type ChildrenOp4SourceReference = SourceReference;
declare type ChildrenOp5IterableIterator = IterableIterator<unknown>;
declare type ChildrenOp7Iterable = Iterable<unknown> | AsyncIterable<unknown>;
declare type ChildrenOp6Promise = Promise<unknown>;
export {};
//# sourceMappingURL=source.d.ts.map