import { CollectionType, EastFunction, PatchType, SetType, Variable, VariantType } from '../east';
import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, EastType, FloatType, IntegerType, Nullable, PrimitiveType, StringType, StructType } from '../east/types';
import { Stream } from '../data';
import type { ModulePath } from '../template';
import { PatchSourceTaskDescription } from '../source/Source';
import type { Field } from 'vega-lite/build/src/channeldef';
import type { TopLevel, TopLevelParameter } from 'vega-lite/build/src/spec/toplevel';
import type { FacetedUnitSpec } from 'vega-lite/build/src/spec/unit';
import { TopLevelSpec } from 'vega-lite/build/src/spec';
import { ArcMark, AreaMark, AxisEncoding, BarMark, BoxPlotMark, CartesianEncodings, ContinuousColorEncoding, DiscreteColorEncoding, FormatEncodings, LineMark, Mark, NumericEncoding, PointMark, RadialEncodings, RectMark, StringEncoding, TemporalEncoding, TickMark } from './Chart';
import { LLMAssistantTaskDescription } from '../llm/LLMBuilder';
import { MapVisual } from './Geo';
/** @internal */
export type StringConstraint = {
    type: 'String';
    range?: EastFunction<SetType<StringType> | DictType<StringType, SetType<StringType>>> | undefined;
};
/** @internal */
export type FloatConstraint = {
    type: 'Float';
    min?: EastFunction<FloatType> | undefined;
    max?: EastFunction<FloatType> | undefined;
};
/** @internal */
export type IntegerConstraint = {
    type: 'Integer';
    min?: EastFunction<IntegerType> | undefined;
    max?: EastFunction<IntegerType> | undefined;
};
/** @internal */
export type DateTimeConstraint = {
    type: 'DateTime';
    min?: EastFunction<DateTimeType> | undefined;
    max?: EastFunction<DateTimeType> | undefined;
};
/** @internal */
export type BooleanConstraint = {
    type: 'Boolean';
};
/** @internal */
export type EditConstraint<T extends PrimitiveType | SetType = PrimitiveType | SetType> = T extends StringType ? StringConstraint : T extends SetType ? StringConstraint : T extends FloatType ? FloatConstraint : T extends IntegerType ? IntegerConstraint : T extends DateTimeType ? DateTimeConstraint : T extends BooleanType ? BooleanConstraint : never;
/** @internal */
export type PrimitiveFieldType<T extends PrimitiveType | SetType = PrimitiveType | SetType> = {
    kind: 'primitive';
    name: string;
    value: Variable<T>;
    constraint?: EditConstraint<T> | undefined;
    readonly?: EastFunction<BooleanType> | undefined;
    display?: EastFunction<StringType> | undefined;
    background?: EastFunction<StringType> | undefined;
    color?: EastFunction<StringType> | undefined;
    target_value?: EastFunction<T> | undefined;
    target_display?: EastFunction<StringType> | undefined;
    tooltip?: EastFunction<EastType> | undefined;
    hidden: boolean;
    hidden_detail: boolean;
};
/** @internal */
export type ArrayFieldType<T extends ArrayType<StructType> = ArrayType<StructType>, P extends Record<string, PrimitiveType | SetType> = Record<string, PrimitiveType | SetType>> = {
    kind: 'array';
    name: string;
    value: Variable<T>;
    fields: Record<keyof P, PrimitiveFieldType<P[keyof P]>>;
    readonly?: EastFunction<BooleanType> | undefined;
    hidden: boolean;
    hidden_detail: boolean;
    writable: WritableCollectionConfiguration;
};
/** @internal */
export type DictFieldType<T extends DictType<StringType, StructType> = DictType<StringType, StructType>, P extends Record<string, PrimitiveType | SetType> = Record<string, PrimitiveType | SetType>> = {
    kind: 'dict';
    name: string;
    value: Variable<T>;
    fields: Record<keyof P, PrimitiveFieldType<P[keyof P]>>;
    readonly?: EastFunction<BooleanType> | undefined;
    hidden?: boolean | undefined;
    hidden_detail: boolean;
    writable: WritableCollectionConfiguration;
};
/** @internal */
export type KeyFieldType = {
    name: string;
    kind: 'key';
    value: Variable<StringType>;
    readonly: EastFunction<BooleanType>;
    hidden: boolean;
    hidden_detail: boolean;
};
/** @internal */
export type ValueColumnType = {
    name: string;
    kind: 'value';
    value: Variable<EastType>;
    readonly: EastFunction<BooleanType>;
    hidden: boolean;
    hidden_detail: boolean;
};
/** @internal */
export type CollectionColumnType<T extends CollectionType | VariantType = CollectionType | VariantType> = {
    name: string;
    kind: 'collection';
    value: Variable<T>;
    readonly: EastFunction<BooleanType>;
    hidden: boolean;
    hidden_detail: boolean;
};
/** @internal */
export type ColumnType = PrimitiveFieldType | ArrayFieldType | DictFieldType | CollectionColumnType | KeyFieldType | ValueColumnType;
/** @internal */
export type InputType = PrimitiveFieldType | ArrayFieldType | DictFieldType | KeyFieldType;
/** @internal */
export type WritableCollectionConfiguration = {
    type: 'collection';
    insert: boolean;
    delete: boolean;
};
/** @internal */
export type WritableTableConfiguration = {
    type: 'writable';
    add: boolean;
    remove: boolean;
    update: boolean;
};
/** @internal */
export type PatchTableConfiguration = {
    type: 'patch';
    add: boolean;
    remove: boolean;
    update: boolean;
    conflicts: Stream<PatchType<DictType<StringType, StructType>>>;
    output: Stream<DictType<StringType, StructType>>;
    base: Stream<DictType<StringType, StructType>>;
    patch: Stream<PatchType<DictType<StringType, StructType>>>;
    task: PatchSourceTaskDescription;
    undo: boolean;
};
/** @internal */
export type ReadonlyTableConfiguration = {
    type: 'none';
    add: false;
    remove: false;
    update: false;
};
/** @internal */
export type TableWriteConfiguration = WritableTableConfiguration | PatchTableConfiguration | ReadonlyTableConfiguration;
/** @internal */
export declare function tableWriteConfiguration(stream: Stream<EastType>): TableWriteConfiguration;
/** @internal A visual displayed as a data grid */
export type StructTableVisual = {
    type: 'table';
    kind: 'struct';
    name: string;
    stream: Stream<DictType<StringType, StructType>>;
    columns: ColumnType[];
    writable: TableWriteConfiguration;
    input_streams: Stream[];
};
/** @internal A visual displayed as a data grid */
export type ArrayTableVisual = {
    type: 'table';
    kind: 'array';
    name: string;
    stream: Stream<ArrayType<StructType>>;
    columns: ColumnType[];
    writable: TableWriteConfiguration;
    input_streams: Stream[];
};
/** @internal */
export type PrimitiveTableVisual = {
    type: 'table';
    kind: 'primitive';
    name: string;
    stream: Stream<DictType<StringType, PrimitiveType> | ArrayType<PrimitiveType>>;
    columns: (PrimitiveFieldType | KeyFieldType)[];
    writable: TableWriteConfiguration;
    input_streams: Stream[];
};
/** @internal */
export type TableVisual = ArrayTableVisual | StructTableVisual | PrimitiveTableVisual;
/** @internal A pivot displayed as a data grid */
export type PivotVisual = {
    type: 'pivot';
    name: string;
    streams: Stream<DictType<StringType, StructType> | ArrayType<StructType>>[];
};
/** @internal A visual displayed as a data grid */
export type FormVisual = {
    type: 'form';
    name: string;
    stream: Stream<StructType>;
    inputs: InputType[];
    writable: TableWriteConfiguration;
    input_streams: Stream[];
};
/**
 * Represents the type for a task within a timeline.
 *
 *  @property label The task's descriptive label {@link StringType}.
 *  @property start The scheduled start date and time of the task {@link DateTimeType}.
 *  @property end The scheduled end date and time of the task {@link DateTimeType}.
 *  @property start_target An optional start date and time that the task aims to begin by {@link DateTimeType}.
 *  @property end_target An optional end date and time that the task aims to be completed by {@link DateTimeType}.
 *  @property color An optional string defining the color associated with the task for UI representation {@link StringType}.
 *  @property opacity An optional float defining the opacity of the task's representation {@link FloatType}.
 *  @property stroke_color An optional string defining the color of the task's border or stroke {@link StringType}.
 *  @property stroke_opacity An optional float defining the opacity of the task's stroke {@link FloatType}.
 *  @property stroke_width An optional float defining the width of the task's stroke {@link FloatType}.
 *  @property stroke_dash An optional structure defining the pattern of the task's stroke, consisting of 'stroke' and 'space' floats {@link StructType}.
 *  @property dependencies An optional set or array of strings, each representing the label of another task that this task depends on ({@link SetType} or {@link ArrayType}).
 *  @property tooltips An optional array of tooltips, each {@link ArrayType} element representing the label and value as a {@link StructType}.
 *
 * @category Layout
 */
export type TimelineTaskType = StructType<{
    id: StringType;
    label: StringType;
    start: DateTimeType;
    end: DateTimeType;
    start_target?: Nullable<DateTimeType> | DateTimeType;
    end_target?: Nullable<DateTimeType> | DateTimeType;
    color?: Nullable<StringType> | StringType;
    opacity?: Nullable<FloatType> | FloatType;
    stroke_color?: Nullable<StringType> | StringType;
    stroke_opacity?: Nullable<FloatType> | FloatType;
    stroke_width?: Nullable<FloatType> | FloatType;
    stroke_dash?: Nullable<StructType<{
        stroke: FloatType;
        space: FloatType;
    }>> | StructType<{
        stroke: FloatType;
        space: FloatType;
    }>;
    dependencies?: SetType<StringType> | ArrayType<StringType>;
    tooltips?: ArrayType<StructType<{
        label: StringType;
        value: StringType;
    }>>;
}>;
/**
 * Represents the type for tasks within a timeline, can be a {@link StructType}, an {@link ArrayType} of {@link StructType}, or a {@link DictType} with {@link StructType} value, mapping strings to task structures, allowing for varied forms of task definitions.
 *
 * @category Layout
 */
export type TimelineTasksType = TimelineTaskType | ArrayType<TimelineTaskType> | DictType<StringType, TimelineTaskType>;
/**
 * Represents the type for a boundary within a timeline, `BoundaryType` is a {@link StructType}, each task structure consists of the following fields:
 *
 * @property date The date and time of the boundary {@link DateTimeType}.
 * @property stroke_color An optional string defining the color of the boundary's border or stroke {@link StringType}.
 * @property stroke_opacity An optional float defining the opacity of the boundary's stroke {@link FloatType}.
 * @property stroke_width An optional float defining the width of the boundary's stroke {@link FloatType}.
 * @property stroke_dash An optional structure defining the pattern of the boundary's stroke, consisting of 'stroke' and 'space' floats {@link StructType}.
 *
 * @category Layout
 */
export type TimelineBoundaryType = StructType<{
    date: DateTimeType;
    stroke_color?: Nullable<StringType> | StringType;
    stroke_opacity?: Nullable<FloatType> | FloatType;
    stroke_width?: Nullable<FloatType> | FloatType;
    stroke_dash?: Nullable<StructType<{
        stroke: FloatType;
        space: FloatType;
    }>> | StructType<{
        stroke: FloatType;
        space: FloatType;
    }>;
}>;
/**
 * Represents the type for an event within a calendar, `CalendarEventType` is a {@link StructType}, each task structure consists of the following fields:
 *
 * @property start The scheduled start date and time of the task {@link DateTimeType}.
 * @property end The scheduled end date and time of the task {@link DateTimeType}.
 * @property label The boundary's descriptive label {@link StringType}.
 * @property color An optional string defining the color associated with the boundary for UI representation {@link StringType}.
 *
 * @category Layout
 */
export type CalendarEventType = StructType<{
    start: DateTimeType;
    end?: DateTimeType;
    label?: Nullable<StringType> | StringType;
    color?: Nullable<StringType> | StringType;
}>;
/** @internal A visual displayed as a data grid */
export type CalendarVisual = {
    type: 'calendar';
    kind: 'dict' | 'array';
    name: string;
    stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>;
    events?: EastFunction<CalendarEventType | ArrayType<CalendarEventType> | DictType<StringType, CalendarEventType>>[];
    input_streams: Stream[];
};
/** @internal A visual displayed as a data grid */
export type BlobUploadVisual = {
    type: 'blob_upload';
    name: string;
    stream: Stream<BlobType>;
};
/** @internal A visual displayed as a data grid */
export type TimelineVisual = {
    type: 'timeline';
    name: string;
    stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>;
    tasks: EastFunction<TimelineTaskType | ArrayType<TimelineTaskType> | DictType<StringType, TimelineTaskType>>[];
    boundaries?: EastFunction<TimelineBoundaryType>[] | undefined;
    columns: ColumnType[];
    writable: TableWriteConfiguration;
    input_streams: Stream[];
};
/** @internal  */
export type PlannerVisual = TimelineVisual | CalendarVisual;
/** @internal */
export declare function toTemporalEncoding(def: TemporalEncoding): {
    title?: string;
    timeUnit?: import("./Chart").DiscreteTimeUnit;
    sort?: import("./Chart").SortOrder;
    field: string;
    type: "nominal" | "ordinal" | "quantitative" | "temporal";
};
/** @internal */
export declare function toNumericEncoding(def: NumericEncoding): {
    bin?: boolean | import("./Chart").Bin;
    stack?: import("./Chart").Normalize | null;
    aggregate?: import("./Chart").Aggregate;
    title?: string;
    sort?: import("./Chart").SortOrder;
    field: string;
    type: import("./Chart").FieldType;
};
/** @internal */
export declare function toStringEncoding(def: StringEncoding): {
    title?: string;
    sort?: {
        order: import("./Chart").SortOrder;
        field?: never;
        op?: never;
    } | {
        field: string;
        order: import("./Chart").SortOrder;
        op: import("./Chart").Aggregate;
    };
    field: string;
    type: import("./Chart").FieldType;
};
/** @internal */
export declare function toColorEncoding(def: DiscreteColorEncoding | ContinuousColorEncoding): {
    bin?: boolean | import("./Chart").Bin;
    scale?: {
        domain: string[];
        range: string[];
    };
    aggregate?: import("./Chart").Aggregate;
    title?: string;
    field: string;
    type: import("./Chart").FieldType;
};
/** @internal */
export declare function toAxisEncoding(def: AxisEncoding): {
    title?: string;
    timeUnit?: import("./Chart").DiscreteTimeUnit;
    sort?: import("./Chart").SortOrder;
    field: string;
    type: "nominal" | "ordinal" | "quantitative" | "temporal";
} | {
    bin?: boolean | import("./Chart").Bin;
    stack?: import("./Chart").Normalize | null;
    aggregate?: import("./Chart").Aggregate;
    title?: string;
    sort?: import("./Chart").SortOrder;
    field: string;
    type: import("./Chart").FieldType;
} | {
    title?: string;
    sort?: {
        order: import("./Chart").SortOrder;
        field?: never;
        op?: never;
    } | {
        field: string;
        order: import("./Chart").SortOrder;
        op: import("./Chart").Aggregate;
    };
    field: string;
    type: import("./Chart").FieldType;
};
/** @internal */
export declare function toPointMark(def: PointMark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    filled?: boolean;
    shape?: import("./Chart").PointShape;
    type: "point";
    tooltip: {
        content: string;
    };
};
/** @internal */
export declare function toBarMark(def: BarMark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    type: "bar";
    tooltip: {
        content: string;
    };
    orient: import("./Chart").Orientation | undefined;
    cornerRadiusTopRight: number;
    cornerRadiusBottomRight: number;
};
/** @internal */
export declare function toLineMark(def: LineMark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    interpolate?: import("./Chart").Interpolate;
    type: "line";
    tooltip: {
        content: string;
    };
};
/** @internal */
export declare function toAreaMark(def: AreaMark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    type: "area";
    interpolate: import("./Chart").Interpolate | undefined;
    tooltip: {
        content: string;
    };
};
/** @internal */
export declare function toRectMark(def: RectMark): {
    type: "rect";
    opacity: number;
    tooltip: {
        content: string;
    };
    fill: string | undefined;
    width: number | undefined;
    height: number | undefined;
    fillOpacity: number;
    stroke: string | undefined;
    strokeWidth: number;
    strokeOpacity: number | undefined;
    strokeDash: [stroke: number, space: number] | undefined;
};
/** @internal */
export declare function toBoxPlotMark(def: BoxPlotMark): {
    thickness?: number;
    strokeDash?: [stroke: number, space: number] | [stroke: number, space: number] | [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number | "filter" | null;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    extent?: number | "stdev" | "stderr" | "min-max" | "ci" | "iqr";
    type: "boxplot" | "errorband" | "errorbar";
    tooltip: {
        content: string;
    };
};
/** @internal */
export declare function toTickMark(def: TickMark): {
    thickness: number;
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    cornerRadius?: number;
    type: "tick";
    tooltip: {
        content: string;
    };
};
/** @internal */
export declare function toArcMark(def: ArcMark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    padAngle?: number;
    cornerRadius?: number;
    type: "arc";
    tooltip: {
        content: string;
    };
    innerRadius: {
        signal: string;
    };
    outerRadius: {
        signal: string;
    };
};
/** @internal */
export declare function toMark(mark: Mark): {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    filled?: boolean;
    shape?: import("./Chart").PointShape;
    type: "point";
    tooltip: {
        content: string;
    };
} | {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    type: "bar";
    tooltip: {
        content: string;
    };
    orient: import("./Chart").Orientation | undefined;
    cornerRadiusTopRight: number;
    cornerRadiusBottomRight: number;
} | {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    interpolate?: import("./Chart").Interpolate;
    type: "line";
    tooltip: {
        content: string;
    };
} | {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    type: "area";
    interpolate: import("./Chart").Interpolate | undefined;
    tooltip: {
        content: string;
    };
} | {
    type: "rect";
    opacity: number;
    tooltip: {
        content: string;
    };
    fill: string | undefined;
    width: number | undefined;
    height: number | undefined;
    fillOpacity: number;
    stroke: string | undefined;
    strokeWidth: number;
    strokeOpacity: number | undefined;
    strokeDash: [stroke: number, space: number] | undefined;
} | {
    thickness?: number;
    strokeDash?: [stroke: number, space: number] | [stroke: number, space: number] | [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number | "filter" | null;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    extent?: number | "stdev" | "stderr" | "min-max" | "ci" | "iqr";
    type: "boxplot" | "errorband" | "errorbar";
    tooltip: {
        content: string;
    };
} | {
    thickness: number;
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    cornerRadius?: number;
    type: "tick";
    tooltip: {
        content: string;
    };
} | {
    strokeDash?: [stroke: number, space: number];
    strokeOpacity?: number;
    strokeWidth?: number;
    stroke?: string;
    fillOpacity?: number;
    fill?: string;
    opacity?: number;
    padAngle?: number;
    cornerRadius?: number;
    type: "arc";
    tooltip: {
        content: string;
    };
    innerRadius: {
        signal: string;
    };
    outerRadius: {
        signal: string;
    };
} | undefined;
/** @internal vega unit spec */
export type VegaViewSpec<F extends Field = Field> = Pick<TopLevel<FacetedUnitSpec<F, TopLevelParameter>>, 'encoding' | 'mark' | 'transform' | 'data'>;
/** @internal */
export declare function fromRadialView(def: RadialEncodings): VegaViewSpec;
/** @internal */
export declare function fromCartesianView(def: CartesianEncodings): VegaViewSpec;
/** @internal */
export declare function specFromVegaViewVisual(def: ViewVisual): TopLevelSpec;
/** @internal */
export declare function specFromVegaLayerVisual(def: LayerVisual): TopLevelSpec;
/** @internal */
export declare function specFromVegaVisual(def: VegaVisual): TopLevelSpec;
/** @internal A visual displayed from a vega specification */
export type SpecView = {
    type: 'spec';
    name: string;
    stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>;
    spec: VegaViewSpec;
    selections: Record<string, EastFunction>;
};
/** @internal */
export type CartesianView = FormatEncodings & CartesianEncodings & {
    stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>;
    selections: Record<string, EastFunction>;
};
export declare function cartesianViewFromEncodings(encodings: FormatEncodings & CartesianEncodings, stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>): ViewVisual;
/** @internal */
export type RadialView = FormatEncodings & RadialEncodings & {
    stream: Stream<DictType<StringType, StructType> | ArrayType<StructType>>;
    selections: Record<string, EastFunction>;
};
/** @internal */
export type View = SpecView | CartesianView | RadialView;
/** @internal */
export type ViewVisual = {
    type: 'view';
    name: string;
    view: View;
};
/** @internal */
export type LayerVisual = {
    type: 'layer';
    name: string;
    views: View[];
};
/** @internal A visual displayed from a vega specification */
export type VegaVisual = ViewVisual | LayerVisual;
/** @internal a panel visual */
export type PanelVisualType = MapVisual | PivotVisual | TableVisual | VegaVisual | TabVisual | PanelVisual | FormVisual | PlannerVisual | BlobUploadVisual;
/** @internal a panel child - either data or container visuals */
type PanelChildVisual = PanelVisualType & {
    percentage: number;
};
/** @internal a panel visual - contains data or container visuals */
export type PanelVisual = {
    type: 'panel';
    orientation: 'row' | 'column';
    visuals: PanelChildVisual[];
};
/** @internal a panel visual */
export type GridVisualType = MapVisual | PivotVisual | TableVisual | VegaVisual | TabVisual | FormVisual | PlannerVisual | BlobUploadVisual;
/** @internal a panel child - either data or container visuals */
type GridChildVisual = GridVisualType & {
    x: number;
    y: number;
    w: number;
    h: number;
    static: boolean;
    minW?: number | undefined;
    maxW?: number | undefined;
    minH?: number | undefined;
    maxH?: number | undefined;
};
/** @internal a panel visual - contains data or container visuals */
export type GridVisual = {
    type: 'grid';
    visuals: GridChildVisual[];
};
/** @internal a tab visual */
export type TabVisualType = MapVisual | PivotVisual | TableVisual | VegaVisual | FormVisual | PlannerVisual | BlobUploadVisual;
/** @internal a tab visual - contains data visuals */
export type TabVisual = {
    type: 'tab';
    visuals: TabVisualType[];
};
/** @internal a header visual - displayed in the header of a layout */
export type HeaderItem = {
    type: 'value';
    name: string;
    stream: Stream;
    input_streams: Stream[];
    value: EastFunction<PrimitiveType>;
    color?: EastFunction<StringType> | undefined;
    tooltip?: EastFunction<EastType> | undefined;
} | {
    type: 'slider';
    name: string;
    stream: Stream<FloatType | IntegerType>;
    input_streams: Stream[];
    min: EastFunction<FloatType | IntegerType>;
    max: EastFunction<FloatType | IntegerType>;
    step?: EastFunction<FloatType | IntegerType> | undefined;
    display?: EastFunction<StringType> | undefined;
    tooltip?: EastFunction<EastType> | undefined;
    target?: EastFunction<FloatType | IntegerType> | undefined;
} | {
    type: 'kpi';
    name: string;
    stream: Stream;
    input_streams: Stream[];
    value: EastFunction<PrimitiveType>;
    target: EastFunction<PrimitiveType>;
    tooltip?: EastFunction<EastType> | undefined;
    comparison: EastFunction<IntegerType | FloatType>;
    goal: 'greater' | 'less' | 'equal';
} | {
    type: 'progress';
    name: string;
    stream: Stream;
    input_streams: Stream[];
    value: EastFunction<IntegerType | FloatType>;
    display?: EastFunction<PrimitiveType> | undefined;
    min?: EastFunction<IntegerType | FloatType> | undefined;
    max?: EastFunction<IntegerType | FloatType> | undefined;
    tooltip?: EastFunction<EastType> | undefined;
};
/** @internal a tab visual - contains data visuals */
export type HeaderVisual = {
    type: 'header';
    items: HeaderItem[];
};
/** @internal a tab visual - contains data visuals */
export type ChatThreadVisual = {
    name: string;
    prompt: Stream<Nullable<StringType>>;
    task: LLMAssistantTaskDescription;
};
/** @internal a tab visual - contains data visuals */
export type ChatVisual = {
    type: 'chat';
    threads: ChatThreadVisual[];
};
/** @internal */
export type TargetToolbar = {
    label: string;
    show_targets: boolean;
};
/** @internal */
export type TaskToolbar = {
    label: string;
    show_idle: boolean;
};
/** @internal */
export type DownloadStream = {
    stream: string;
    format: 'json' | 'jsonl' | 'bytes' | 'csv';
};
/** @internal */
export type DownloadToolbar = {
    label: string;
    streams: Record<string, DownloadStream>;
};
/** @internal */
export type ErrorsToolbar = {
    label: string;
};
/** @internal layout visual - a named visual element that can be used in a portal */
export type LayoutToolbar = {
    targets?: TargetToolbar | undefined;
    tasks?: TaskToolbar | undefined;
    downloads?: DownloadToolbar | undefined;
    errors?: ErrorsToolbar | undefined;
};
/** @internal container visual - either a tab or panel */
export type FlatLayoutVisualType = MapVisual | VegaVisual | PivotVisual | TableVisual | TabVisual | PanelVisual | GridVisual | FormVisual | HeaderVisual | PlannerVisual | BlobUploadVisual;
/** @internal flat layout visual - a named visual element that can be used in a portal */
export type FlatLayoutVisual = {
    type: 'flat';
    name: string;
    caption?: string | undefined;
    visual: FlatLayoutVisualType;
    header?: HeaderVisual | undefined;
    chat?: ChatVisual | undefined;
    toolbar?: LayoutToolbar | undefined;
};
/** @internal */
export type PagedVisualType = FlatLayoutVisual;
/** @internal paged layout visual - a named visual element that contains multiple flat layouts */
export type PagedLayoutVisual = {
    type: 'paged';
    name: string;
    visuals: PagedVisualType[];
};
/** @internal */
export type AccordionVisualType = PagedLayoutVisual | FlatLayoutVisual;
/** @internal */
export type AccordionVisualGroup = {
    name: string;
    visuals: AccordionVisualType[];
};
/** @internal layout visual - a named visual element that can be used in a portal */
export type AccordionLayoutVisual = {
    type: 'accordion';
    name: string;
    groups: AccordionVisualGroup[];
    numbered: boolean;
};
/** @internal layout visual */
export type LayoutVisualType = FlatLayoutVisual | PagedLayoutVisual | AccordionLayoutVisual;
/** @internal layout visual */
export type LayoutVisual = {
    name: string;
    module: ModulePath;
    visual: LayoutVisualType;
    inputs: Record<string, Stream>;
};
/** @internal container visual - either a tab or panel */
export type Visual = FlatLayoutVisual | PagedLayoutVisual | AccordionLayoutVisual | MapVisual | VegaVisual | PivotVisual | TableVisual | TabVisual | PanelVisual | GridVisual | FormVisual | HeaderVisual | PlannerVisual | BlobUploadVisual;
/** @internal  */
export declare function visualStreams(visual: Visual, streams: Stream[]): Stream[];
/** @internal  */
export declare function visualEditStreams(visual: Visual, streams: Stream[]): Stream[];
export {};