import type { IPivotTableLabelFieldJSON, IPivotViewJSON } from '@univerjs-pro/engine-pivot';
import type { IPivotSlicerCacheDefinition, ISlicerResource, ISlicerViewConfig, ITimelineCacheDefinition, ITimelineRange, ITimelineViewConfig, SlicerCacheDefinition, SlicerControlKind, SlicerSourceKind, SlicerTargetKind } from '@univerjs-pro/slicer';
import type { IMutationInfo, IRange, RecordSelection, RecordValue } from '@univerjs/core';
import type { ITableFilterItem, TableColumnFilterTypeEnum } from '@univerjs/sheets-table';
import type { ISlicerSheetEffects } from './services/slicer-sheet-effects';
export declare enum SlicerIntentType {
    CreateSlicer = "createSlicer",
    CreateTimeline = "createTimeline",
    SetDateRange = "setDateRange",
    RemoveView = "removeView",
    UpdateView = "updateView",
    PatchView = "patchView",
    PatchCacheOptions = "patchCacheOptions",
    UpdateCache = "updateCache",
    RemoveCache = "removeCache",
    ChangeConnections = "changeConnections",
    Clear = "clear",
    SetSelection = "setSelection"
}
export declare enum SlicerRPCRequestKind {
    Metadata = "metadata",
    ConnectionCandidates = "connectionCandidates",
    Prepare = "prepare",
    PivotSelection = "pivotSelection",
    Members = "members"
}
export declare enum SlicerDerivedStateStatus {
    Ready = "ready",
    Stale = "stale",
    Error = "error"
}
export declare enum SlicerTransactionErrorCode {
    InvalidResource = "invalid-resource",
    InvalidTarget = "invalid-target",
    Stale = "stale",
    UnsupportedSideEffect = "unsupported-side-effect",
    PermissionDenied = "permission-denied"
}
export declare enum SlicerSourceErrorCode {
    CapabilityMissing = "capability-missing",
    SourceMissing = "source-missing",
    FieldMissing = "field-missing",
    FieldUnsupported = "field-unsupported",
    SourceNotReady = "source-not-ready"
}
export declare enum SlicerRPCErrorCode {
    Aborted = "SLICER_RPC_ABORTED",
    Timeout = "SLICER_RPC_TIMEOUT",
    Disposed = "SLICER_RPC_DISPOSED",
    UnitDisposed = "SLICER_RPC_UNIT_DISPOSED",
    DispatchFailed = "SLICER_RPC_DISPATCH_FAILED",
    InvalidResponse = "SLICER_RPC_INVALID_RESPONSE"
}
export type SlicerResourceCollection = 'slicerCaches' | 'slicers' | 'timelineCaches' | 'timelines';
export type SlicerEntityChange = {
    [K in SlicerResourceCollection]: {
        collection: K;
        id: string;
        before: ISlicerResource[K][number] | null;
        after: ISlicerResource[K][number] | null;
    };
}[SlicerResourceCollection];
export type SlicerSourceDefinition = SlicerCacheDefinition | ITimelineCacheDefinition;
/** A sheet anchor; offsets are CSS pixels. */
export type SheetSlicerAnchorSpec = string | {
    row: number;
    column: number;
    rowOffset?: number;
    columnOffset?: number;
};
export type SheetSlicerSourceSpec = {
    kind: SlicerSourceKind.Table;
    subUnitId: string;
    tableId: string;
    columnId: string;
} | {
    kind: SlicerSourceKind.Pivot;
    pivotCacheId: string;
    sourceFieldId: string;
    pivotTables: IPivotSlicerCacheDefinition['pivotTables'];
    ownedPivotCharts?: IPivotSlicerCacheDefinition['ownedPivotCharts'];
};
export type SheetTimelineSourceSpec = Extract<SheetSlicerSourceSpec, {
    kind: SlicerSourceKind.Pivot;
}>;
/** View configuration with rowHeight in CSS pixels, not resource EMU. */
export type SheetSlicerSettings = ISlicerViewConfig;
export type SheetTimelineSettings = ITimelineViewConfig;
export type SheetSlicerCacheOptions = Omit<IPivotSlicerCacheDefinition['data'], 'pivotCacheId'> & {
    hideItemsWithNoData?: boolean;
};
export interface ISheetSlicerInfo {
    dataSource: SheetSlicerSourceSpec;
    settings: Omit<SheetSlicerSettings, 'name'> & {
        name?: string;
    };
    anchor?: SheetSlicerAnchorSpec;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
}
export interface ISheetTimelineInfo {
    dataSource: SheetTimelineSourceSpec;
    settings: Omit<SheetTimelineSettings, 'name'> & {
        name?: string;
    };
    anchor?: SheetSlicerAnchorSpec;
    position?: {
        x: number;
        y: number;
    };
    size?: {
        width: number;
        height: number;
    };
}
export interface ISheetSlicerItemsRequest {
    start?: number;
    count?: number;
    signal?: AbortSignal;
}
export interface ISheetSlicerConnections {
    pivotTables: IPivotSlicerCacheDefinition['pivotTables'];
    ownedPivotCharts?: IPivotSlicerCacheDefinition['ownedPivotCharts'];
}
export type SlicerInsertTarget = {
    kind: SlicerTargetKind.Table;
    unitId: string;
    subUnitId: string;
    tableId: string;
} | {
    kind: SlicerTargetKind.PivotTable;
    unitId: string;
    subUnitId: string;
    pivotTableId: string;
} | {
    kind: SlicerTargetKind.PivotChart;
    unitId: string;
    subUnitId: string;
    pivotChartId: string;
};
export type SlicerInsertResolvedTarget = Exclude<SlicerInsertTarget, {
    kind: SlicerTargetKind.PivotChart;
}> | {
    kind: SlicerTargetKind.OwnedPivotChart;
    unitId: string;
    subUnitId: string;
    pivotChartId: string;
};
export interface ISlicerInsertFieldOption {
    fieldId: string;
    name: string;
    controls: SlicerControlKind[];
    target: SlicerInsertResolvedTarget;
}
export interface ISlicerInsertIdentity {
    cacheId: string;
    viewId: string;
}
export interface ISlicerInsertPlan {
    intent: Extract<SlicerIntent, {
        type: SlicerIntentType.CreateSlicer | SlicerIntentType.CreateTimeline;
    }>;
    kind: SlicerControlKind;
    subUnitId: string;
    viewId: string;
}
export type SlicerIntent = {
    type: SlicerIntentType.CreateSlicer;
    cache: SlicerCacheDefinition;
    view: ISlicerResource['slicers'][number];
} | {
    type: SlicerIntentType.CreateTimeline;
    cache: ITimelineCacheDefinition;
    view: ISlicerResource['timelines'][number];
} | {
    type: SlicerIntentType.SetDateRange;
    cacheId: string;
    range?: ITimelineRange;
} | {
    type: SlicerIntentType.RemoveView;
    kind: SlicerControlKind;
    id: string;
} | {
    type: SlicerIntentType.UpdateView;
    kind: SlicerControlKind.Slicer;
    view: ISlicerResource['slicers'][number];
} | {
    type: SlicerIntentType.UpdateView;
    kind: SlicerControlKind.Timeline;
    view: ISlicerResource['timelines'][number];
} | {
    type: SlicerIntentType.PatchView;
    kind: SlicerControlKind.Slicer;
    id: string;
    patch: Partial<SheetSlicerSettings>;
} | {
    type: SlicerIntentType.PatchView;
    kind: SlicerControlKind.Timeline;
    id: string;
    patch: Partial<SheetTimelineSettings>;
} | {
    type: SlicerIntentType.PatchCacheOptions;
    kind: SlicerControlKind.Slicer;
    cacheId: string;
    patch: SheetSlicerCacheOptions;
} | {
    type: SlicerIntentType.UpdateCache;
    kind: SlicerControlKind.Slicer;
    cache: SlicerCacheDefinition;
} | {
    type: SlicerIntentType.UpdateCache;
    kind: SlicerControlKind.Timeline;
    cache: ITimelineCacheDefinition;
} | {
    type: SlicerIntentType.RemoveCache;
    kind: SlicerControlKind;
    cacheId: string;
} | {
    type: SlicerIntentType.ChangeConnections;
    kind: SlicerControlKind;
    cacheId: string;
    pivotTables: IPivotSlicerCacheDefinition['pivotTables'];
    ownedPivotCharts?: IPivotSlicerCacheDefinition['ownedPivotCharts'];
} | {
    type: SlicerIntentType.Clear;
    kind: SlicerControlKind;
    cacheId: string;
} | {
    type: SlicerIntentType.SetSelection;
    cacheId: string;
    selection: RecordSelection;
};
export interface ISlicerCommandParams {
    unitId: string;
    intent: SlicerIntent;
}
export interface ISlicerTableChange {
    tableId: string;
    subUnitId: string;
    columnId: string;
    before: ITableFilterItem | null;
    after: ITableFilterItem | null;
}
export interface IApplySlicerBatchMutationParams {
    unitId: string;
    entities: SlicerEntityChange[];
    pivots: ISlicerPivotChange[];
}
export interface ISlicerPreparedBatch extends IApplySlicerBatchMutationParams {
    tables: ISlicerTableChange[];
    sheetEffects: ISlicerSheetEffects;
}
export interface ISlicerPreparedTransaction {
    validate: () => void;
    forward: IApplySlicerBatchMutationParams;
    inverse: IApplySlicerBatchMutationParams;
    redoMutations: IMutationInfo[];
    undoMutations: IMutationInfo[];
}
export interface ISlicerWorkerPreparation {
    forward: ISlicerPreparedBatch;
    inverse: ISlicerPreparedBatch;
    pivotViews: {
        subUnitId: string;
        pivotTableId: string;
        view: IPivotViewJSON;
    }[];
}
export interface ISlicerPivotChange {
    kind: SlicerTargetKind.PivotTable | SlicerTargetKind.OwnedPivotChart;
    subUnitId: string;
    id: string;
    pivotCacheId: string;
    sourceFieldId: string;
    beforeRanges: IRange[];
    afterRanges: IRange[];
    fields: {
        id: string;
        before: IPivotTableLabelFieldJSON | null;
        after: IPivotTableLabelFieldJSON | null;
        hiddenBefore: number;
        hiddenAfter: number;
    }[];
}
export declare class SlicerTransactionError extends Error {
    readonly code: SlicerTransactionErrorCode;
    constructor(code: SlicerTransactionErrorCode);
}
export interface ISlicerSourceMetadata {
    fieldId: string;
    name: string;
    ready: boolean;
    timeline?: {
        minDate?: number;
        maxDate?: number;
        interactive: boolean;
    };
}
export interface ISlicerConnectionCandidate {
    kind: SlicerTargetKind.PivotTable | SlicerTargetKind.OwnedPivotChart;
    subUnitId: string;
    id: string;
    name: string;
    sheetName: string;
}
export interface ISlicerMemberWindowRequest {
    start: number;
    count: number;
    control?: SlicerControlKind;
    signal?: AbortSignal;
}
export interface ISlicerSourceMemberWindow {
    total: number;
    items: {
        key: string;
        value: RecordValue;
        hasData: boolean;
    }[];
}
export type SlicerRPCRequest = {
    kind: SlicerRPCRequestKind.Metadata;
    unitId: string;
    source: SlicerSourceDefinition;
} | {
    kind: SlicerRPCRequestKind.ConnectionCandidates;
    unitId: string;
    source: IPivotSlicerCacheDefinition | ITimelineCacheDefinition;
} | {
    kind: SlicerRPCRequestKind.Prepare;
    unitId: string;
    params: ISlicerCommandParams;
} | {
    kind: SlicerRPCRequestKind.PivotSelection;
    unitId: string;
    source: IPivotSlicerCacheDefinition;
    checkedItems: string[];
    partialItems: string[];
    isAll: boolean;
} | {
    kind: SlicerRPCRequestKind.Members;
    unitId: string;
    source: SlicerSourceDefinition;
    start: number;
    count: number;
    control?: SlicerControlKind;
};
export type SlicerRPCResponse = {
    kind: SlicerRPCRequestKind.Metadata;
    metadata: ISlicerSourceMetadata;
} | {
    kind: SlicerRPCRequestKind.ConnectionCandidates;
    candidates: ISlicerConnectionCandidate[];
} | {
    kind: SlicerRPCRequestKind.Prepare;
    preparation: ISlicerWorkerPreparation;
} | {
    kind: SlicerRPCRequestKind.PivotSelection;
    selection: RecordSelection;
} | {
    kind: SlicerRPCRequestKind.Members;
    metadata: ISlicerSourceMetadata;
    window: ISlicerSourceMemberWindow;
};
export interface IRequestSlicerDataLocalMutationParams {
    requestId: string;
    unitId: string;
    request: SlicerRPCRequest;
}
export interface ISendSlicerDataLocalMutationParams {
    requestId: string;
    unitId: string;
    response?: SlicerRPCResponse;
    error?: string;
    domainError?: {
        kind: 'source';
        code: SlicerSourceErrorCode;
    } | {
        kind: 'transaction';
        code: SlicerTransactionErrorCode;
    };
}
export interface ISlicerDerivedTarget {
    kind: SlicerTargetKind.PivotTable | SlicerTargetKind.OwnedPivotChart;
    subUnitId: string;
    id: string;
}
export interface ISlicerDerivedState extends ISlicerDerivedTarget {
    status: SlicerDerivedStateStatus;
    error?: string;
}
export interface ICancelSlicerRequestLocalMutationParams {
    requestId: string;
    unitId: string;
}
export type TableSlicerSelection = RecordSelection | {
    mode: TableColumnFilterTypeEnum.manual | TableColumnFilterTypeEnum.condition | TableColumnFilterTypeEnum.color;
};
export declare class SlicerSourceError extends Error {
    readonly code: SlicerSourceErrorCode;
    constructor(code: SlicerSourceErrorCode);
}
export declare class SlicerRPCError extends Error {
    readonly code: Exclude<SlicerRPCErrorCode, SlicerRPCErrorCode.Aborted>;
    constructor(code: Exclude<SlicerRPCErrorCode, SlicerRPCErrorCode.Aborted>);
}