import * as React from "react";
import { PureComponent, ReactNode } from "react";
type BlockId = string | symbol;
type BlockNamespace = string | symbol;
interface NamespaceRecord {
    key: BlockNamespace;
    blocks: Record<BlockId, Block_[]>;
    blockSubscriptions: Record<BlockId, (block: Block_) => void>;
}
type NamespaceArg = BlockNamespace | NamespaceRecord;
declare class BlockStore {
    private namespaces;
    protected useNamespace<T>(key: NamespaceArg, f: (ns: NamespaceRecord) => T): T;
    private emitter;
    listen: {
        <E extends "block_registered" | "block_unregistered" | "block_switched">(event: E, f: (...params: {
            block_registered: [block: BlockId, namespace: BlockNamespace];
            block_unregistered: [block: BlockId, namespace: BlockNamespace];
            block_switched: [block: BlockId, namespace: BlockNamespace];
        }[E]) => void): any;
        <E_1 extends "block_registered" | "block_unregistered" | "block_switched">(events: E_1[], f: (...params: {
            block_registered: [block: BlockId, namespace: BlockNamespace];
            block_unregistered: [block: BlockId, namespace: BlockNamespace];
            block_switched: [block: BlockId, namespace: BlockNamespace];
        }[E_1]) => void): any;
    };
    protected transitionBlock(namespace: NamespaceRecord, id: BlockId, transaction: () => void): void;
    registerBlock(blk: Block_): void;
    unregisterBlock(blk: Block_): void;
    subscribeBlock(namespace: NamespaceArg, blk: BlockId, callback: (block: Block_) => void): () => void;
    isBlockProvided(namespace: NamespaceArg, blk: BlockId): boolean;
    activeBlock(namespace: NamespaceArg, blk: BlockId): Block_;
}
export declare const ProvideBlocks: React.FC<{
    children?: ReactNode;
    namespace?: string;
}>;
interface BlockProps {
    block: BlockId;
    namespace?: string;
    priority?: number;
    eager?: boolean;
    cache?: number | boolean;
    suppressed?: boolean;
    store?: BlockStore;
    children?: ReactNode;
}
declare class Block_ extends PureComponent<BlockProps> {
    get store(): BlockStore;
    state: {
        shouldRender: boolean;
    };
    get name(): BlockId;
    get priority(): number;
    get namespace(): string;
    private _element;
    get element(): any;
    private unusedTimer;
    protected setUsed(used: boolean): void;
    protected updateRegistration(): void;
    componentDidMount(): void;
    componentDidUpdate(prevProps: Readonly<BlockProps>): void;
    componentWillUnmount(): void;
    private mountedParent;
    private mountedPlaceholder;
    mountOutput(newPlaceholder: HTMLDivElement): void;
    unmountOutput(expectedPlaceholder?: HTMLDivElement): void;
    render(): React.ReactPortal;
}
declare const InternalBlock: React.FC<BlockProps>;
interface UseBlockProps {
    block: BlockId;
    namespace?: string;
    store?: BlockStore;
}
export declare const UseBlock: React.FC<UseBlockProps & {
    children?: ReactNode;
}>;
declare const BlockApi: {
    Use: React.FC<UseBlockProps & {
        children?: ReactNode;
    }>;
    Provide: React.FC<{
        children?: ReactNode;
        namespace?: string;
    }>;
    _useStore: () => BlockStore;
    useIsProvided: (block: BlockId | BlockId[], mode: "any" | "all", opts?: {
        store?: BlockStore;
        namespace?: BlockNamespace;
    }) => boolean;
    IfBlockProvided: (props: {
        block: BlockId | BlockId[];
        any?: boolean;
        namespace?: BlockNamespace;
        children: React.ReactNode;
    }) => JSX.Element;
};
/**
 * Block-based rendering in React, similar to Django templates. Mainly intended for use in libraries as a replacement for passing elements as props.
 *
 * Blocks may receive an optional `priority` prop, which determines which block is rendered when multiple blocks are defined with the same name.
 * It is generally intended that Blocks are singletons, but there are some use cases where it is easier to override a Block multiple times
 *
 * Example Usage:
 * ```tsx
 * <ProvideBlocks>
 *     <UseBlock block="bob">
 *         Optional Default Content
 *     </UseBlock>
 *
 *     <UserProvidedComponent>
 *         <Block block="bob">
 *             User Overridden Content
 *         </Block>
 *     </UserProvidedComponent>
 * </ProvideBlocks>
 * ```
 *
 * NB: Blocks are rendered where they are defined, not where they are used.
 * This means that `Block`s (and their descendants) will receive Context from where they are placed in the hierarchy, not from where `UseBlock` is placed.
 */
export declare const Block: typeof InternalBlock & typeof BlockApi;
export {};