import { ReactiveControllerHost } from 'lit';
import { OmitTypesFromRecord, ReadonlyIfType } from '../../global/helpers';
import { ConsumeContextOptions, ContextConsumerController } from './ContextConsumerController';
import { ContextProviderController, ProvideContextOptions } from './ContextProviderController';
/**
 * Creates and returns a pairable context consumer and provider.
 */
export declare function createContext<T>(initialValue: T): Context<T>;
/**
 * Derives a context from others that was created with `createContext`. This assumes the
 * given `contexts` are ALL provided by the same host element.
 *
 * @param contexts - The contexts to derive values from as it updates.
 * @param derivation - Takes the original context values and outputs the derived value.
 */
export declare function derivedContext<T extends ContextTuple, R>(contexts: T, derivation: (values: ContextTupleValues<T>) => R): DerivedContext<R>;
export declare function isDerviedContext<T>(context: Context<T> | DerivedContext<T>): context is DerivedContext<T>;
/**
 * Takes in a context record which is essentially an object containing 0 or more contexts, and sets
 * the given `host` element as the provider of all the contexts within the given record.
 *
 * @param host
 * @param contextRecord
 */
export declare function provideContextRecord<T extends ContextRecord<unknown>>(host: ReactiveControllerHost, contextRecord: T, options?: {
    [P in keyof T]?: Omit<ProvideContextOptions<T[P]>, 'id'>;
}): ContextProviderRecord<T>;
export interface Context<T> {
    readonly id: symbol;
    readonly initialValue: T;
    provide(host: ReactiveControllerHost, options?: Omit<ProvideContextOptions<T>, 'id'>): ContextProviderController<T>;
    consume(host: ReactiveControllerHost, options?: Omit<ConsumeContextOptions<T>, 'id'>): ContextConsumerController<T>;
}
export declare type DerivedContext<T> = Context<T> & {
    isDerived: true;
};
export declare type ExtractContextType<C> = C extends Context<infer X> ? X : never;
export declare type ContextTuple = readonly [Context<any>, ...Array<Context<any>>];
export declare type ContextTupleValues<Tuple> = {
    readonly [K in keyof Tuple]: ExtractContextType<Tuple[K]>;
};
export declare type ContextRecord<RecordType> = {
    readonly [P in keyof RecordType]: Context<RecordType[P]> | DerivedContext<RecordType[P]>;
};
export declare type ExtractContextRecordTypes<ContextRecordType extends ContextRecord<any>> = {
    [P in keyof ContextRecordType]: ExtractContextType<ContextRecordType[P]>;
};
export declare type ContextProviderRecord<ContextRecordType extends ContextRecord<any>> = ExtractContextRecordTypes<ReadonlyIfType<DerivedContext<any>, ContextRecordType>> & {
    __destroy: () => void;
};
export declare type OmitDerivedContextFromRecord<RecordType> = OmitTypesFromRecord<RecordType, DerivedContext<any>>;