import type { ReactNode } from 'react';
import type { Filter } from '../treeParameters';
import { Schema, SchemaColumn, SchemaEntity, SchemaRelation } from '../core/schema';
import { GraphQlLiteral } from '@contember/client';
declare class Environment {
    private readonly options;
    private constructor();
    static create(): Environment;
    getSubTree(): Environment.SubTreeNode;
    getSubTreeNode(): Environment.AnyNode;
    withSubTree(SubTree: Environment.SubTreeNode): Environment;
    withSubTreeChild(node: Environment.InnerNode): Environment;
    hasVariable(key: string): boolean;
    getVariable<V extends Environment.Value = Environment.Value>(key: string): V;
    getVariableOrElse<F, V extends Environment.Value = Environment.Value>(key: string, fallback: F): V | F;
    /** @deprecated use getVariable or getParameter */
    getValue<V extends Environment.Value = Environment.Value>(key: string): V;
    /** @deprecated use getVariableOrElse or getParameterOrElse */
    getValueOrElse<F, V extends Environment.Value = Environment.Value>(key: string, fallback: F): V | F;
    /** @deprecated */
    hasName(key: string): boolean;
    withVariables(variables: Environment.ValuesMapWithFactory | undefined): Environment;
    getAllVariables(): Environment.CustomVariables;
    hasParameter(key: string): boolean;
    getParameter<F>(key: string): string | number;
    getParameterOrElse<F>(key: string, fallback: F): string | number | F;
    getAllParameters(): Environment.Parameters;
    withParameters(parameters: Environment.Parameters): Environment;
    hasDimension(dimensionName: string): boolean;
    getDimension<F>(dimensionName: string): string[];
    getDimensionOrElse<F>(dimensionName: string, fallback: F): string[] | F;
    getAllDimensions(): Environment.SelectedDimensions;
    withDimensions(dimensions: Environment.SelectedDimensions): Environment;
    getSchema(): Schema;
    withSchema(schema: Schema): Environment;
    getParent(): Environment;
    withExtension<S, R>(extension: Environment.Extension<S, R>, state: S): Environment;
    getExtension<S, R>(extension: Environment.Extension<S, R>): R;
    merge(other: Environment): Environment;
}
declare namespace Environment {
    type Name = string;
    type Value = ReactNode | GraphQlLiteral | Filter;
    type ResolvedValue = Value;
    interface Options {
        node?: AnyNode;
        schema?: Schema;
        dimensions: SelectedDimensions;
        parameters: Parameters;
        variables: CustomVariables;
        parent?: Environment;
        extensions: Map<Extension<unknown, unknown>, unknown>;
    }
    type SubTreeNode = SubTreeEntityNode | SubTreeEntityListNode;
    type InnerNode = EntityNode | EntityListNode | ColumnNode;
    type AnyNode = SubTreeNode | InnerNode;
    interface SubTreeEntityNode {
        type: 'subtree-entity';
        entity: SchemaEntity;
        expectedCardinality: 'zero' | 'one' | 'zero-or-one';
        filter: Filter;
    }
    interface SubTreeEntityListNode {
        type: 'subtree-entity-list';
        entity: SchemaEntity;
        expectedCardinality: 'zero-to-many' | 'zero';
        filter: Filter;
    }
    interface EntityNode {
        type: 'entity';
        entity: SchemaEntity;
        field: SchemaRelation;
    }
    interface EntityListNode {
        type: 'entity-list';
        entity: SchemaEntity;
        field: SchemaRelation;
    }
    interface ColumnNode {
        type: 'column';
        entity: SchemaEntity;
        field: SchemaColumn;
    }
    interface SelectedDimensions {
        [key: string]: string[];
    }
    type Parameters = {
        [K in string]?: string | number;
    };
    interface CustomVariables {
        [key: string]: Value;
    }
    interface ValuesMapWithFactory {
        [key: string]: ((environment: Environment) => Value) | Value;
    }
    type Extension<State, Result> = {
        create: (state: State | undefined, environment: Environment) => Result;
    };
    const createExtension: <S, R>(create: (state: S | undefined, environment: Environment) => R, otherMethods?: Omit<Extension<S, R>, "create"> | undefined) => Extension<S, R>;
    /** @deprecated */
    type DeltaFactory = ValuesMapWithFactory;
}
export { Environment };
//# sourceMappingURL=Environment.d.ts.map