@univerjs/sheets-conditional-formatting 0.1.5

package/lib/types/base/const.d.ts

@@ -0,0 +1,66 @@
+import { IConditionFormattingRule } from '../models/type';
+
+export declare const SHEET_CONDITIONAL_FORMATTING_PLUGIN = "SHEET_CONDITIONAL_FORMATTING_PLUGIN";
+export declare enum CFTextOperator {
+    beginsWith = "beginsWith",
+    endsWith = "endsWith",
+    containsText = "containsText",
+    notContainsText = "notContainsText",
+    equal = "equal",
+    notEqual = "notEqual",
+    containsBlanks = "containsBlanks",
+    notContainsBlanks = "notContainsBlanks",
+    containsErrors = "containsErrors",
+    notContainsErrors = "notContainsErrors"
+}
+export declare enum CFTimePeriodOperator {
+    today = "today",
+    yesterday = "yesterday",
+    tomorrow = "tomorrow",
+    last7Days = "last7Days",
+    thisMonth = "thisMonth",
+    lastMonth = "lastMonth",
+    nextMonth = "nextMonth",
+    thisWeek = "thisWeek",
+    lastWeek = "lastWeek",
+    nextWeek = "nextWeek"
+}
+export declare enum CFNumberOperator {
+    greaterThan = "greaterThan",
+    greaterThanOrEqual = "greaterThanOrEqual",
+    lessThan = "lessThan",
+    lessThanOrEqual = "lessThanOrEqual",
+    notBetween = "notBetween",
+    between = "between",
+    equal = "equal",
+    notEqual = "notEqual"
+}
+export declare enum CFRuleType {
+    highlightCell = "highlightCell",
+    dataBar = "dataBar",
+    colorScale = "colorScale",
+    iconSet = "iconSet"
+}
+export declare enum CFSubRuleType {
+    uniqueValues = "uniqueValues",
+    duplicateValues = "duplicateValues",
+    rank = "rank",
+    text = "text",
+    timePeriod = "timePeriod",
+    number = "number",
+    average = "average",
+    formula = "formula"
+}
+export declare enum CFValueType {
+    num = "num",
+    min = "min",
+    max = "max",
+    percent = "percent",
+    percentile = "percentile",
+    formula = "formula"
+}
+export declare const DEFAULT_BG_COLOR = "#fff";
+export declare const DEFAULT_FONT_COLOR = "#000000";
+export declare const createDefaultRule: () => IConditionFormattingRule<import('../models/type').IConditionalFormattingRuleConfig>;
+export declare const createDefaultValue: (subType: CFSubRuleType, operator: CFTextOperator | CFNumberOperator | CFTimePeriodOperator) => "" | 10 | [number, number];
+export declare const createDefaultValueByValueType: (type: CFValueType, defaultValue?: number) => number | "" | "=";

package/lib/types/commands/commands/add-average-cf.command.d.ts

@@ -0,0 +1,11 @@
+import { IAverageHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddAverageCfParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: IAverageHighlightCell['style'];
+    operator: IAverageHighlightCell['operator'];
+}
+export declare const DddAverageCfCommand: ICommand<IAddAverageCfParams>;
+export {};

package/lib/types/commands/commands/add-cf.command.d.ts

@@ -0,0 +1,10 @@
+import { MakePropertyOptional } from '../../utils/type';
+import { IConditionFormattingRule } from '../../models/type';
+import { ICommand } from '@univerjs/core';
+
+export interface IAddCfCommandParams {
+    unitId?: string;
+    subUnitId?: string;
+    rule: MakePropertyOptional<IConditionFormattingRule, 'cfId'>;
+}
+export declare const AddCfCommand: ICommand<IAddCfCommandParams>;

package/lib/types/commands/commands/add-color-scale-cf.command.d.ts

@@ -0,0 +1,10 @@
+import { IColorScale } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddColorScaleConditionalRuleParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    config: IColorScale['config'];
+}
+export declare const AddColorScaleConditionalRuleCommand: ICommand<IAddColorScaleConditionalRuleParams>;
+export {};

package/lib/types/commands/commands/add-data-bar-cf.command.d.ts

@@ -0,0 +1,14 @@
+import { IDataBar } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddUniqueValuesConditionalRuleParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    min: IDataBar['config']['min'];
+    max: IDataBar['config']['max'];
+    nativeColor: IDataBar['config']['nativeColor'];
+    positiveColor: IDataBar['config']['positiveColor'];
+    isGradient: IDataBar['config']['isGradient'];
+}
+export declare const AddDataBarConditionalRuleCommand: ICommand<IAddUniqueValuesConditionalRuleParams>;
+export {};

package/lib/types/commands/commands/add-duplicate-values-cf.command.d.ts

@@ -0,0 +1,10 @@
+import { IHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddDuplicateValuesConditionalRuleParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: IHighlightCell['style'];
+}
+export declare const AddDuplicateValuesCfCommand: ICommand<IAddDuplicateValuesConditionalRuleParams>;
+export {};

package/lib/types/commands/commands/add-number-cf.command.d.ts

@@ -0,0 +1,12 @@
+import { INumberHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddNumberCfParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: INumberHighlightCell['style'];
+    operator: INumberHighlightCell['operator'];
+    value: number | [number, number];
+}
+export declare const AddNumberCfCommand: ICommand<IAddNumberCfParams>;
+export {};

package/lib/types/commands/commands/add-rank-cf.command.d.ts

@@ -0,0 +1,13 @@
+import { IRankHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddRankCfParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: IRankHighlightCell['style'];
+    isPercent: boolean;
+    isBottom: boolean;
+    value: number;
+}
+export declare const AddRankCfCommand: ICommand<IAddRankCfParams>;
+export {};

package/lib/types/commands/commands/add-text-cf.command.d.ts

@@ -0,0 +1,12 @@
+import { ITextHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddAverageCfParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: ITextHighlightCell['style'];
+    operator: ITextHighlightCell['operator'];
+    value: ITextHighlightCell['value'];
+}
+export declare const AddTextCfCommand: ICommand<IAddAverageCfParams>;
+export {};

package/lib/types/commands/commands/add-time-period-cf.command.d.ts

@@ -0,0 +1,11 @@
+import { ITimePeriodHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddTimePeriodCf {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: ITimePeriodHighlightCell['style'];
+    operator: ITimePeriodHighlightCell['operator'];
+}
+export declare const AddTimePeriodCfCommand: ICommand<IAddTimePeriodCf>;
+export {};

package/lib/types/commands/commands/add-unique-values-cf.command.d.ts

@@ -0,0 +1,10 @@
+import { IHighlightCell } from '../../models/type';
+import { ICommand, IRange } from '@univerjs/core';
+
+interface IAddUniqueValuesConditionalRuleParams {
+    ranges: IRange[];
+    stopIfTrue?: boolean;
+    style: IHighlightCell['style'];
+}
+export declare const AddUniqueValuesCfCommand: ICommand<IAddUniqueValuesConditionalRuleParams>;
+export {};

package/lib/types/commands/commands/clear-range-cf.command.d.ts

@@ -0,0 +1,8 @@
+import { ICommand, IRange } from '@univerjs/core';
+
+export interface IClearRangeCfParams {
+    ranges?: IRange[];
+    unitId?: string;
+    subUnitId?: string;
+}
+export declare const ClearRangeCfCommand: ICommand<IClearRangeCfParams>;

package/lib/types/commands/commands/clear-worksheet-cf.command.d.ts

@@ -0,0 +1,7 @@
+import { ICommand } from '@univerjs/core';
+
+export interface IClearWorksheetCfParams {
+    unitId?: string;
+    subUnitId?: string;
+}
+export declare const ClearWorksheetCfCommand: ICommand<IClearWorksheetCfParams>;

package/lib/types/commands/commands/delete-cf.command.d.ts

@@ -0,0 +1,8 @@
+import { ICommand } from '@univerjs/core';
+
+export interface IDeleteCfCommandParams {
+    unitId?: string;
+    subUnitId?: string;
+    cfId: string;
+}
+export declare const DeleteCfCommand: ICommand<IDeleteCfCommandParams>;

package/lib/types/commands/commands/move-cf.command.d.ts

@@ -0,0 +1,9 @@
+import { ICommand } from '@univerjs/core';
+
+export interface IMoveCfCommand {
+    unitId?: string;
+    subUnitId?: string;
+    cfId: string;
+    targetCfId: string;
+}
+export declare const moveCfCommand: ICommand<IMoveCfCommand>;

package/lib/types/commands/commands/set-cf.command.d.ts

@@ -0,0 +1,9 @@
+import { IConditionFormattingRule } from '../../models/type';
+import { ICommand } from '@univerjs/core';
+
+export interface ISetCfCommandParams {
+    unitId?: string;
+    subUnitId?: string;
+    rule: IConditionFormattingRule;
+}
+export declare const SetCfCommand: ICommand<ISetCfCommandParams>;

package/lib/types/commands/mutations/add-conditional-rule.mutation.d.ts

@@ -0,0 +1,15 @@
+import { IDeleteConditionalRuleMutationParams } from './delete-conditional-rule.mutation';
+import { IConditionFormattingRule } from '../../models/type';
+import { IAccessor } from '@wendellhu/redi';
+import { IMutation } from '@univerjs/core';
+
+export interface IAddConditionalRuleMutationParams {
+    unitId: string;
+    subUnitId: string;
+    rule: IConditionFormattingRule;
+}
+export declare const AddConditionalRuleMutationUndoFactory: (accessor: IAccessor, param: IAddConditionalRuleMutationParams) => {
+    id: string;
+    params: IDeleteConditionalRuleMutationParams;
+};
+export declare const AddConditionalRuleMutation: IMutation<IAddConditionalRuleMutationParams>;

package/lib/types/commands/mutations/delete-conditional-rule.mutation.d.ts

@@ -0,0 +1,10 @@
+import { IAccessor } from '@wendellhu/redi';
+import { IMutation, IMutationInfo } from '@univerjs/core';
+
+export interface IDeleteConditionalRuleMutationParams {
+    unitId: string;
+    subUnitId: string;
+    cfId: string;
+}
+export declare const DeleteConditionalRuleMutationUndoFactory: (accessor: IAccessor, param: IDeleteConditionalRuleMutationParams) => IMutationInfo<object>[];
+export declare const DeleteConditionalRuleMutation: IMutation<IDeleteConditionalRuleMutationParams>;

package/lib/types/commands/mutations/formula-mark-dirty.mutation.d.ts

@@ -0,0 +1,10 @@
+import { IMutation } from '@univerjs/core';
+
+export interface IConditionalFormattingFormulaMarkDirtyParams {
+    [unitId: string]: {
+        [sunUnitId: string]: {
+            [formulaId: string]: boolean;
+        };
+    };
+}
+export declare const ConditionalFormattingFormulaMarkDirty: IMutation<IConditionalFormattingFormulaMarkDirtyParams>;

package/lib/types/commands/mutations/move-conditional-rule.mutation.d.ts

@@ -0,0 +1,14 @@
+import { IAccessor } from '@wendellhu/redi';
+import { IMutation } from '@univerjs/core';
+
+export interface IMoveConditionalRuleMutationParams {
+    unitId: string;
+    subUnitId: string;
+    cfId: string;
+    targetCfId: string;
+}
+export declare const MoveConditionalRuleMutation: IMutation<IMoveConditionalRuleMutationParams>;
+export declare const MoveConditionalRuleMutationUndoFactory: (accessor: IAccessor, param: IMoveConditionalRuleMutationParams) => {
+    id: string;
+    params: IMoveConditionalRuleMutationParams;
+}[];

package/lib/types/commands/mutations/set-conditional-rule.mutation.d.ts

@@ -0,0 +1,14 @@
+import { IConditionFormattingRule } from '../../models/type';
+import { IAccessor } from '@wendellhu/redi';
+import { IMutation } from '@univerjs/core';
+
+export interface ISetConditionalRuleMutationParams {
+    unitId: string;
+    subUnitId: string;
+    rule: IConditionFormattingRule;
+}
+export declare const SetConditionalRuleMutation: IMutation<ISetConditionalRuleMutationParams>;
+export declare const setConditionalRuleMutationUndoFactory: (accessor: IAccessor, param: ISetConditionalRuleMutationParams) => {
+    id: string;
+    params: ISetConditionalRuleMutationParams;
+}[];

package/lib/types/commands/operations/open-conditional-formatting-panel.d.ts

@@ -0,0 +1,15 @@
+import { ICommand } from '@univerjs/core';
+
+export declare enum CF_MENU_OPERATION {
+    createRule = 1,
+    viewRule = 2,
+    highlightCell = 3,
+    rank = 4,
+    formula = 5,
+    colorScale = 6,
+    dataBar = 7,
+    icon = 8,
+    clearRangeRules = 9,
+    clearWorkSheetRules = 10
+}
+export declare const OpenConditionalFormattingOperator: ICommand;

package/lib/types/components/color-picker/index.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+
+interface IColorPickerProps {
+    color: string;
+    onChange: (color: string) => void;
+    disable?: boolean;
+    iconId?: string;
+    className?: string;
+    isNeedDropdownIcon?: boolean;
+}
+export declare const ColorPicker: (props: IColorPickerProps) => React.JSX.Element | undefined;
+export {};

package/lib/types/components/conditional-style-editor/index.d.ts

@@ -0,0 +1,10 @@
+import { IHighlightCell } from '../../models/type';
+import { default as React } from 'react';
+
+interface IConditionalStyleEditorProps {
+    className?: string;
+    style?: IHighlightCell['style'];
+    onChange: (style: IHighlightCell['style']) => void;
+}
+export declare const ConditionalStyleEditor: (props: IConditionalStyleEditorProps) => React.JSX.Element;
+export {};

package/lib/types/components/panel/index.d.ts

@@ -0,0 +1,8 @@
+import { IConditionFormattingRule } from '../../models/type';
+import { default as React } from 'react';
+
+interface IConditionFormattingPanelProps {
+    rule?: IConditionFormattingRule;
+}
+export declare const ConditionFormattingPanel: (props: IConditionFormattingPanelProps) => React.JSX.Element;
+export {};

package/lib/types/components/panel/rule-edit/colorScale.d.ts

@@ -0,0 +1,4 @@
+import { IStyleEditorProps } from './type';
+import { default as React } from 'react';
+
+export declare const ColorScaleStyleEditor: (props: IStyleEditorProps) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/dataBar.d.ts

@@ -0,0 +1,4 @@
+import { IStyleEditorProps } from './type';
+import { default as React } from 'react';
+
+export declare const DataBarStyleEditor: (props: IStyleEditorProps) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/formula.d.ts

@@ -0,0 +1,4 @@
+import { IStyleEditorProps } from './type';
+import { default as React } from 'react';
+
+export declare const FormulaStyleEditor: (props: IStyleEditorProps) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/highlightCell.d.ts

@@ -0,0 +1,5 @@
+import { IStyleEditorProps } from './type';
+import { INumberHighlightCell, ITextHighlightCell, ITimePeriodHighlightCell } from '../../../models/type';
+import { default as React } from 'react';
+
+export declare const HighlightCellStyleEditor: (props: IStyleEditorProps<any, ITextHighlightCell | INumberHighlightCell | ITimePeriodHighlightCell>) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/iconSet.d.ts

@@ -0,0 +1,5 @@
+import { IStyleEditorProps } from './type';
+import { IIconSet } from '../../../models/type';
+import { default as React } from 'react';
+
+export declare const IconSet: (props: IStyleEditorProps<unknown, IIconSet>) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/index.d.ts

@@ -0,0 +1,9 @@
+import { IConditionFormattingRule } from '../../../models/type';
+import { default as React } from 'react';
+
+interface IRuleEditProps {
+    rule?: IConditionFormattingRule;
+    onCancel: () => void;
+}
+export declare const RuleEdit: (props: IRuleEditProps) => React.JSX.Element;
+export {};

package/lib/types/components/panel/rule-edit/rank.d.ts

@@ -0,0 +1,4 @@
+import { IStyleEditorProps } from './type';
+import { default as React } from 'react';
+
+export declare const RankStyleEditor: (props: IStyleEditorProps) => React.JSX.Element;

package/lib/types/components/panel/rule-edit/type.d.ts

@@ -0,0 +1,13 @@
+import { IConditionalFormattingRuleConfig } from '../../../models/type';
+import { InterceptorManager } from '@univerjs/core';
+
+export declare const beforeSubmit: import('@univerjs/core').IInterceptor<boolean, null>;
+export declare const submit: import('@univerjs/core').IInterceptor<any, null>;
+export interface IStyleEditorProps<S = any, R = IConditionalFormattingRuleConfig> {
+    onChange: (style: S) => void;
+    rule?: R;
+    interceptorManager: InterceptorManager<{
+        beforeSubmit: typeof beforeSubmit;
+        submit: typeof submit;
+    }>;
+}

package/lib/types/components/panel/rule-list/index.d.ts

@@ -0,0 +1,9 @@
+import { IConditionFormattingRule } from '../../../models/type';
+import { default as React } from 'react';
+
+interface IRuleListProps {
+    onClick: (rule: IConditionFormattingRule) => void;
+    onCreate: () => void;
+}
+export declare const RuleList: (props: IRuleListProps) => React.JSX.Element;
+export {};

package/lib/types/components/preview/index.d.ts

@@ -0,0 +1,6 @@
+import { IConditionalFormattingRuleConfig } from '../../models/type';
+import { default as React } from 'react';
+
+export declare const Preview: (props: {
+    rule?: IConditionalFormattingRuleConfig;
+}) => React.JSX.Element | null | undefined;

package/lib/types/controllers/cf.auto-fill.controller.d.ts

@@ -0,0 +1,15 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
+import { Injector } from '@wendellhu/redi';
+import { IAutoFillService } from '@univerjs/sheets-ui';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export declare class ConditionalFormattingAutoFillController extends Disposable {
+    private _injector;
+    private _univerInstanceService;
+    private _autoFillService;
+    private _conditionalFormattingRuleModel;
+    private _conditionalFormattingViewModel;
+    constructor(_injector: Injector, _univerInstanceService: IUniverInstanceService, _autoFillService: IAutoFillService, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _conditionalFormattingViewModel: ConditionalFormattingViewModel);
+    private _initAutoFill;
+}

package/lib/types/controllers/cf.clear.controller.d.ts

@@ -0,0 +1,14 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { Injector } from '@wendellhu/redi';
+import { SelectionManagerService, SheetInterceptorService } from '@univerjs/sheets';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export declare class ConditionalFormattingClearController extends Disposable {
+    private _injector;
+    private _univerInstanceService;
+    private _sheetInterceptorService;
+    private _selectionManagerService;
+    private _conditionalFormattingRuleModel;
+    constructor(_injector: Injector, _univerInstanceService: IUniverInstanceService, _sheetInterceptorService: SheetInterceptorService, _selectionManagerService: SelectionManagerService, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel);
+    private _init;
+}

package/lib/types/controllers/cf.copy-paste.controller.d.ts

@@ -0,0 +1,18 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
+import { Injector } from '@wendellhu/redi';
+import { ISheetClipboardService } from '@univerjs/sheets-ui';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export declare class ConditionalFormattingCopyPasteController extends Disposable {
+    private _sheetClipboardService;
+    private _conditionalFormattingRuleModel;
+    private _injector;
+    private _conditionalFormattingViewModel;
+    private _univerInstanceService;
+    private _copyInfo;
+    constructor(_sheetClipboardService: ISheetClipboardService, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _injector: Injector, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _univerInstanceService: IUniverInstanceService);
+    private _initClipboardHook;
+    private _collectConditionalRule;
+    private _generateConditionalFormattingMutations;
+}

package/lib/types/controllers/cf.editor.controller.d.ts

@@ -0,0 +1,15 @@
+import { ConditionalFormattingService } from '../services/conditional-formatting.service';
+import { IEditorBridgeService } from '@univerjs/sheets-ui';
+import { Disposable } from '@univerjs/core';
+
+export declare class ConditionalFormattingEditorController extends Disposable {
+    private _editorBridgeService;
+    private _conditionalFormattingService;
+    constructor(_editorBridgeService: IEditorBridgeService, _conditionalFormattingService: ConditionalFormattingService);
+    /**
+     * Process the  values after  edit
+     * @private
+     * @memberof NumfmtService
+     */
+    private _initInterceptorEditorEnd;
+}

package/lib/types/controllers/cf.i18n.controller.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { Disposable, LocaleService } from '@univerjs/core';
+
+export declare class ConditionalFormattingI18nController extends Disposable {
+    private _localeService;
+    constructor(_localeService: LocaleService);
+    private _initLocal;
+    tWithReactNode(key: string, ...args: (ReactNode | string)[]): ReactNode[];
+    private _findReplaceIndex;
+}

package/lib/types/controllers/cf.menu.controller.d.ts

@@ -0,0 +1,16 @@
+import { IConditionFormattingRule } from '../models/type';
+import { ComponentManager, IMenuService, ISidebarService } from '@univerjs/ui';
+import { Disposable, LocaleService } from '@univerjs/core';
+import { Injector } from '@wendellhu/redi';
+
+export declare class ConditionalFormattingMenuController extends Disposable {
+    private _injector;
+    private _componentManager;
+    private _menuService;
+    private _sidebarService;
+    private _localeService;
+    constructor(_injector: Injector, _componentManager: ComponentManager, _menuService: IMenuService, _sidebarService: ISidebarService, _localeService: LocaleService);
+    openPanel(rule?: IConditionFormattingRule): void;
+    private _initMenu;
+    private _initPanel;
+}

package/lib/types/controllers/cf.ref-range.controller.d.ts

@@ -0,0 +1,15 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { Injector } from '@wendellhu/redi';
+import { RefRangeService } from '@univerjs/sheets';
+import { SheetSkeletonManagerService } from '@univerjs/sheets-ui';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export declare class RefRangeController extends Disposable {
+    private _conditionalFormattingRuleModel;
+    private _univerInstanceService;
+    private _injector;
+    private _sheetSkeletonManagerService;
+    private _refRangeService;
+    constructor(_conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _univerInstanceService: IUniverInstanceService, _injector: Injector, _sheetSkeletonManagerService: SheetSkeletonManagerService, _refRangeService: RefRangeService);
+    private _initRefRange;
+}

package/lib/types/controllers/cf.render.controller.d.ts

@@ -0,0 +1,21 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
+import { ConditionalFormattingService } from '../services/conditional-formatting.service';
+import { IRenderManagerService } from '@univerjs/engine-render';
+import { SheetSkeletonManagerService } from '@univerjs/sheets-ui';
+import { SheetInterceptorService } from '@univerjs/sheets';
+import { Disposable, IUniverInstanceService } from '@univerjs/core';
+
+export declare class RenderController extends Disposable {
+    private _sheetInterceptorService;
+    private _conditionalFormattingService;
+    private _univerInstanceService;
+    private _renderManagerService;
+    private _conditionalFormattingViewModel;
+    private _conditionalFormattingRuleModel;
+    private _sheetSkeletonManagerService;
+    constructor(_sheetInterceptorService: SheetInterceptorService, _conditionalFormattingService: ConditionalFormattingService, _univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _sheetSkeletonManagerService: SheetSkeletonManagerService);
+    _initRender(): void;
+    _initSkeleton(): void;
+    _initViewModelInterceptor(): void;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { SheetsConditionalFormattingPlugin } from './plugin';
+export { enUS, zhCN } from './locale';

package/lib/types/locale/en-US.d.ts

@@ -0,0 +1,4 @@
+import { default as zhCN } from './zh-CN';
+
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { default as enUS } from './en-US';
+export { default as zhCN } from './zh-CN';