Class: FPivotTableEvent

new FPivotTableEvent(): FPivotTableEvent

get BeforeCommandExecute(): "BeforeCommandExecute"

univerAPI.addEvent(univerAPI.event.BeforeCommandExecute, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get BeforePivotTableAdd(): "BeforePivotTableAdd"

univerAPI.addEvent(univerAPI.Event.BeforePivotTableAdd, (params) => {
    const { positionType, targetCellInfo } = params;
    if (positionType === univerAPI.Enum.PositionTypeEnum.Existing && targetCellInfo.sheetName === 'Sheet 1') {
        params.cancel = true;
        console.log(`The pivot table can't be added to the sheet ${targetCellInfo.sheetName}`);
    }
});

IPivotTableEventMixin.BeforePivotTableAdd

FEventName.BeforePivotTableAdd

get BeforeRedo(): "BeforeRedo"

univerAPI.addEvent(univerAPI.event.BeforeRedo, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get BeforeSheetCreate(): "BeforeSheetCreate"

univerAPI.addEvent(univerAPI.event.BeforeSheetCreate, (params) => {
     const { workbook, index, sheet } = params;
    console.log('unit created', params);
});

FEventName.BeforeSheetCreate

get BeforeUndo(): "BeforeUndo"

univerAPI.addEvent(univerAPI.event.BeforeUndo, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get CommandExecuted(): "CommandExecuted"

univerAPI.addEvent(univerAPI.event.CommandExecuted, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get DocCreated(): "DocCreated"

univerAPI.addEvent(univerAPI.event.DocCreated, (params) => {
    const { unitId, type, doc, unit } = params;
    console.log('doc created', params);
});

get DocDisposed(): "DocDisposed"

univerAPI.addEvent(univerAPI.event.DocDisposed, (params) => {
    const { unitId, unitType, snapshot } = params;
    console.log('doc disposed', params);
});

get LifeCycleChanged(): "LifeCycleChanged"

univerAPI.addEvent(univerAPI.event.LifeCycleChanged, (params) => {
     const { stage } = params;
    console.log('life cycle changed', params);
});

get PivotTableAdded(): "PivotTableAdded"

univerAPI.addEvent(univerAPI.Event.PivotTableAdded, (params) => {
    const { positionType, targetCellInfo } = params;
    if (positionType === univerAPI.Enum.PositionTypeEnum.Existing) {
        console.log('A pivot table created in an existing sheet');
        console.log(`The target sheet name is ${targetCellInfo.sheetName}, the target row is ${targetCellInfo.row}, the target column is ${targetCellInfo.column}`);
    } else {
        console.log('A pivot table created in a new sheet');
    }
});

IPivotTableEventMixin.PivotTableAdded

FEventName.PivotTableAdded

get PivotTableFieldAdded(): "PivotTableFieldAdded"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldAdded, (params) => {
   const { pivotTableId, fieldId, fieldArea, fieldIndex } = params;
   const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
   const fieldSetting = pivotTable.getFieldSetting('fieldId');
   console.log(fieldSetting);

IPivotTableEventMixin.PivotTableFieldAdded

FEventName.PivotTableFieldAdded

get PivotTableFieldCollapseChanged(): "PivotTableFieldCollapseChanged"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldCollapseChanged, (params) => {
  const { pivotTableId, fieldId, isCollapsed } = params;
  const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
  const fieldSetting = pivotTable.getFieldSetting(fieldId);
  console.log(`The source name ${fieldSetting.sourceName} the display name ${fieldSetting.displayName}`);
});
 
##### Returns
 
`"PivotTableFieldCollapseChanged"`
 
#### Implementation of
 
```ts
IPivotTableEventMixin.PivotTableFieldCollapseChanged

FEventName.PivotTableFieldCollapseChanged

get PivotTableFieldFilterChanged(): "PivotTableFieldFilterChanged"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldFilterChanged, (params) => {
    const { pivotTableId, fieldId, filter } = params;
    const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
    const fieldSetting = pivotTable.getFieldSetting(fieldId);
    console.log(`The Checklist filter value is ${fieldSetting.filterInfo.checklist}`);
});

IPivotTableEventMixin.PivotTableFieldFilterChanged

FEventName.PivotTableFieldFilterChanged

get PivotTableFieldMoved(): "PivotTableFieldMoved"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldMoved, (params) => {
   const { pivotTableId, fieldId, fieldArea, fieldIndex } = params;
  const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
  const fieldSetting = pivotTable.getFieldSetting(fieldId);
  console.log(`The source name ${fieldSetting.sourceName} the display name ${fieldSetting.displayName}`);
});

IPivotTableEventMixin.PivotTableFieldMoved

FEventName.PivotTableFieldMoved

get PivotTableFieldRemoved(): "PivotTableFieldRemoved"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldRemoved, (params) => {
    const { pivotTableId, fieldId } = params;
    const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
    const fieldSetting = pivotTable.getFieldSetting(fieldId);
    console.log(fieldSetting);
});

IPivotTableEventMixin.PivotTableFieldRemoved

FEventName.PivotTableFieldRemoved

get PivotTableFieldSettingChanged(): "PivotTableFieldSettingChanged"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldSettingChanged, (params) => {
    const { pivotTableId, fieldId, setting } = params;
    const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
    const fieldSetting = pivotTable.getFieldSetting(fieldId);
    console.log(`The source name ${fieldSetting.sourceName} the display name ${fieldSetting.displayName}`);
});

IPivotTableEventMixin.PivotTableFieldSettingChanged

FEventName.PivotTableFieldSettingChanged

get PivotTableFieldSortChanged(): "PivotTableFieldSortChanged"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableFieldSortChanged, (params) => {
   const { pivotTableId, fieldId, sort } = params;
   const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
   const fieldSetting = pivotTable.getFieldSetting(fieldId);
   console.log(`The sort info is ${fieldSetting.sortInfo}`);
});

IPivotTableEventMixin.PivotTableFieldSortChanged

FEventName.PivotTableFieldSortChanged

get PivotTableMoved(): "PivotTableMoved"

univerAPI.addEvent(univerAPI.Event.PivotTableMoved, (params) => {
    const { pivotTableId, targetCellInfo, originTargetInfo } = params;
    if (pivotTableId === 'pivotTable1') {
        console.log(`The pivot table moved from row: ${originTargetInfo.row} & column: ${originTargetInfo.column} to the sheet ${targetCellInfo.sheetName} row: ${targetCellInfo.row} & column: ${targetCellInfo.column}`);
    }
});

IPivotTableEventMixin.PivotTableMoved

FEventName.PivotTableMoved

get PivotTableRemoved(): "PivotTableRemoved"

univerAPI.addEvent(univerAPI.Event.PivotTableRemoved, (params) => {
   const { pivotTableId } = params;
   console.log(`The pivot table ${pivotTableId} has been removed`);
});
 
##### Returns
 
`"PivotTableRemoved"`
 
#### Implementation of
 
```ts
IPivotTableEventMixin.PivotTableRemoved

FEventName.PivotTableRemoved

get PivotTableRendered(): "PivotTableRendered"

// import { unionPivotViewRange } from '@univerjs-pro/sheets-pivot';
univerAPI.addEvent(univerAPI.Event.PivotTableRendered, (params) => {
    const { pivotTableId, rangeInfo } = params;
    console.log(`The pivot table ${pivotTableId} has been rendered`);
    if (rangeInfo) {
        console.log(unionPivotViewRange(rangeInfo));
    }
});

IPivotTableEventMixin.PivotTableRendered

FEventName.PivotTableRendered

get PivotTableValuePositionChanged(): "PivotTableValuePositionChanged"

const fWorkbook = univerAPI.getActiveWorkbook();
univerAPI.addEvent(univerAPI.Event.PivotTableValuePositionChanged, (params) => {
    const { pivotTableId, valueId, position } = params;
    const pivotTable = fWorkbook.getPivotTableById(pivotTableId);
    const valueSetting = pivotTable.getValueSetting(valueId);
    console.log(`The source name ${valueSetting.sourceName} the display name ${valueSetting.displayName}`);
});

IPivotTableEventMixin.PivotTableValuePositionChanged

FEventName.PivotTableValuePositionChanged

get Redo(): "Redo"

univerAPI.addEvent(univerAPI.event.Redo, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get SheetCreated(): "SheetCreated"

univerAPI.addEvent(univerAPI.event.SheetCreated, (params) => {
     const { workbook, worksheet } = params;
    console.log('unit created', params);
});

FEventName.SheetCreated

get Undo(): "Undo"

univerAPI.addEvent(univerAPI.event.Undo, (event) => {
    const { params, id, type } = event;
    console.log('command executed', event);
});

get WorkbookCreated(): "WorkbookCreated"

univerAPI.addEvent(univerAPI.event.WorkbookCreated, (params) => {
     const { unitId, type, workbook, unit } = params;
    console.log('unit created', params);
});

FEventName.WorkbookCreated

get WorkbookDisposed(): "WorkbookDisposed"

univerAPI.addEvent(univerAPI.event.WorkbookDisposed, (params) => {
     const { unitId, unitType, snapshot } = params;
    console.log('unit disposed', params);
});

FEventName.WorkbookDisposed

static extend(source): void

static get(): FEventName