@adaptabletools/adaptable 11.3.0 → 12.0.0-canary.0

package/src/Api/Implementation/LayoutApiImpl.d.ts

@@ -3,7 +3,8 @@ import { LayoutApi } from '../LayoutApi';
 import { LayoutState, Layout } from '../../PredefinedConfig/LayoutState';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { ColumnSort } from '../../PredefinedConfig/Common/ColumnSort';
-import { LayoutAssociatedObject } from '../../types';
+import { ColumnFilter, LayoutAssociatedObject } from '../../types';
+import { RowNode } from '@ag-grid-community/all-modules';
 export declare class LayoutApiImpl extends ApiBase implements LayoutApi {
     getLayoutState(): LayoutState;
     shouldAutoSaveLayout: (layout?: Layout) => boolean;
@@ -42,4 +43,20 @@ export declare class LayoutApiImpl extends ApiBase implements LayoutApi {
     isCurrentLayoutDefault(): boolean;
     areExpandedRowGroupsSavedInLayouts(): boolean;
     isObjectAvailableInCurrentLayout(adaptableObject: LayoutAssociatedObject): boolean;
+    getAllColumnFilter(): ColumnFilter[];
+    getColumnFilterById(id: ColumnFilter['Uuid']): ColumnFilter;
+    setColumnFilter(columnFilters: ColumnFilter[]): ColumnFilter[] | null;
+    clearColumnFilter(columnFilter: ColumnFilter): void;
+    clearColumnFilterByColumns(columns: string[]): void;
+    clearColumnFilterByColumn(column: string): void;
+    clearAllColumnFilter(): void;
+    clearAndSetColumnFilter(columnFilters: ColumnFilter[]): void;
+    getAllColumnFilterForColumn(column: string): ColumnFilter[];
+    createColumnFilterForCell(columnId: string, primarykeyValues: any[]): ColumnFilter | null;
+    columnFilterToString(columnFilter: ColumnFilter): string;
+    columnFiltersToString(columnFilters: ColumnFilter[]): string;
+    evaluateColumnFilter(columnFilter: ColumnFilter, node: RowNode): boolean;
+    removeColumnFromCurrentLayout(columnId: string): void;
+    removeColumnFromAllLayouts(columnId: string): void;
+    removeColumnFromLayout(columnId: string, layoutName: string): void;
 }

package/src/Api/Implementation/LayoutApiImpl.js

@@ -321,5 +321,177 @@ class LayoutApiImpl extends ApiBase_1.ApiBase {
             ? true
             : (_a = adaptableObject.Tags) === null || _a === void 0 ? void 0 : _a.map((tag) => tag).includes(this.getCurrentLayoutName());
     }
+    getAllColumnFilter() {
+        var _a;
+        const currentLayout = this.getCurrentLayout();
+        return (_a = currentLayout.ColumnFilters) !== null && _a !== void 0 ? _a : [];
+    }
+    getColumnFilterById(id) {
+        var _a;
+        return (_a = this.getAllColumnFilter()) === null || _a === void 0 ? void 0 : _a.find((columnFilter) => columnFilter.Uuid === id);
+    }
+    setColumnFilter(columnFilters) {
+        columnFilters.forEach((columnFilter) => {
+            if (!columnFilter.Predicate) {
+                LoggingHelper_1.LogAdaptableWarning('Column Filter has no Predicate', columnFilter);
+            }
+            else {
+                const isValidPredicate = this.adaptable.api.predicateApi.isValidPredicate(columnFilter.Predicate);
+                if (!isValidPredicate) {
+                    LoggingHelper_1.LogAdaptableWarning('Column Filter Predicate is not valid', columnFilter);
+                }
+                else {
+                    this.addUidToAdaptableObject(columnFilter);
+                    if (this.getAllColumnFilter().find((cf) => cf.ColumnId == columnFilter.ColumnId)) {
+                        this.dispatchAction(LayoutRedux.LayoutColumnFilterSet(columnFilter));
+                    }
+                    else {
+                        this.dispatchAction(LayoutRedux.LayoutColumnFilterAdd(columnFilter));
+                    }
+                }
+                return columnFilters === null || columnFilters === void 0 ? void 0 : columnFilters.map((columnFilter) => this.getColumnFilterById(columnFilter.Uuid));
+            }
+        });
+        return null;
+    }
+    clearColumnFilter(columnFilter) {
+        this.dispatchAction(LayoutRedux.LayoutColumnFilterClear(columnFilter));
+    }
+    clearColumnFilterByColumns(columns) {
+        columns.forEach((c) => {
+            this.clearColumnFilterByColumn(c);
+        });
+    }
+    clearColumnFilterByColumn(column) {
+        let columnFiltersForColumn = this.getAllColumnFilterForColumn(column);
+        if (columnFiltersForColumn) {
+            columnFiltersForColumn.forEach((cf) => {
+                this.dispatchAction(LayoutRedux.LayoutColumnFilterClear(cf));
+            });
+            this.adaptable.clearColumnFiltering([column]);
+        }
+    }
+    clearAllColumnFilter() {
+        this.dispatchAction(LayoutRedux.LayoutColumnFilterClearAll());
+        this.adaptable.clearGridFiltering();
+    }
+    clearAndSetColumnFilter(columnFilters) {
+        this.clearAllColumnFilter();
+        columnFilters.forEach((columnFilter) => {
+            if (this.getAllColumnFilter().find((cf) => cf.ColumnId == columnFilter.ColumnId)) {
+                this.dispatchAction(LayoutRedux.LayoutColumnFilterSet(columnFilter));
+            }
+            else {
+                this.dispatchAction(LayoutRedux.LayoutColumnFilterAdd(columnFilter));
+            }
+        });
+    }
+    getAllColumnFilterForColumn(column) {
+        let columnFilters = this.getAllColumnFilter();
+        if (columnFilters) {
+            return columnFilters.filter((cf) => cf.ColumnId == column);
+        }
+        else {
+            return [];
+        }
+    }
+    createColumnFilterForCell(columnId, primarykeyValues) {
+        let cellValues = [];
+        let predicateId;
+        if (primarykeyValues.length == 1) {
+            const normalisedValue = this.adaptable.api.gridApi.getCellNormalisedValue(primarykeyValues[0], columnId);
+            if (normalisedValue) {
+                cellValues.push(normalisedValue);
+                const dataType = this.adaptable.api.columnApi.getColumnDataTypeFromColumnId(columnId);
+                if (dataType) {
+                    if (dataType == 'Number') {
+                        predicateId = 'Equals';
+                    }
+                    else if (dataType == 'Date') {
+                        predicateId = 'On';
+                    }
+                    else if (dataType == 'String') {
+                        predicateId = 'Is';
+                    }
+                    else {
+                        predicateId = 'Equals';
+                    }
+                }
+            }
+        }
+        else {
+            primarykeyValues.forEach((pk) => {
+                const displayValue = this.adaptable.api.gridApi.getCellDisplayValue(pk, columnId);
+                if (displayValue && !cellValues.includes(displayValue)) {
+                    cellValues.push(displayValue);
+                }
+            });
+            predicateId = 'Values';
+        }
+        const filter = {
+            ColumnId: columnId,
+            Predicate: {
+                PredicateId: predicateId,
+                Inputs: [...new Set(cellValues)],
+            },
+        };
+        const [savedFilter] = this.setColumnFilter([filter]) || [null];
+        return savedFilter;
+    }
+    columnFilterToString(columnFilter) {
+        const friendlyName = this.adaptable.api.columnApi.getFriendlyNameFromColumnId(columnFilter.ColumnId);
+        return ('[' +
+            friendlyName +
+            '] ' +
+            this.adaptable.api.predicateApi.predicateToString(columnFilter.Predicate));
+    }
+    columnFiltersToString(columnFilters) {
+        return columnFilters.map((cf) => this.columnFilterToString(cf)).join(', ');
+    }
+    evaluateColumnFilter(columnFilter, node) {
+        var _a;
+        if (!columnFilter.Predicate) {
+            return true;
+        }
+        if ((_a = columnFilter.Predicate.Inputs) === null || _a === void 0 ? void 0 : _a.some((input) => StringExtensions_1.default.IsNullOrEmpty(input))) {
+            return true;
+        }
+        const column = this.adaptable.api.columnApi.getColumnFromId(columnFilter.ColumnId);
+        if (!column) {
+            return true;
+        }
+        const gridCell = this.adaptable.api.gridApi.getGridCellFromRowNode(node, columnFilter.ColumnId);
+        if (!gridCell) {
+            return true;
+        }
+        let value = gridCell.normalisedValue;
+        return this.adaptable.api.predicateApi.handlePredicate(columnFilter.Predicate, {
+            value: value,
+            oldValue: null,
+            displayValue: gridCell.displayValue,
+            node,
+            column,
+        }, true);
+    }
+    removeColumnFromCurrentLayout(columnId) {
+        this.removeColumnFromLayout(columnId, this.getCurrentLayoutName());
+    }
+    removeColumnFromAllLayouts(columnId) {
+        this.getAllLayout().forEach((layout) => {
+            this.removeColumnFromLayout(columnId, layout.Name);
+        });
+    }
+    removeColumnFromLayout(columnId, layoutName) {
+        const column = this.getAdaptableApi().columnApi.getColumnFromId(columnId);
+        if (column) {
+            const layout = this.getLayoutByName(layoutName);
+            if (layout) {
+                if (layout.Columns.includes(columnId)) {
+                    this.dispatchAction(LayoutRedux.LayouRemoveColumn(layoutName, columnId));
+                    this.getAdaptableApi().columnApi.hideColumn(columnId);
+                }
+            }
+        }
+    }
 }
 exports.LayoutApiImpl = LayoutApiImpl;

package/src/Api/Implementation/PredicateApiImpl.js

@@ -15,7 +15,7 @@ class PredicateApiImpl extends ApiBase_1.ApiBase {
         return AdaptablePredicate_1.SystemPredicateDefs;
     }
     getCustomPredicateDefs() {
-        return this.adaptable.adaptableOptions.customPredicateDefs;
+        return this.getAdaptableQLOptions().customPredicateDefs;
     }
     getPredicateDefsByModuleScope(moduleScope) {
         return this.getPredicateDefs().filter((p) => p.moduleScope.includes(moduleScope));

package/src/Api/Implementation/SmartEditApiImpl.d.ts

@@ -1,13 +1,15 @@
 import { ApiBase } from './ApiBase';
+import { MathOperation } from '../../PredefinedConfig/Common/Enums';
 import { SmartEditApi } from '../SmartEditApi';
 import { GridCell } from '../../PredefinedConfig/Selection/GridCell';
 import { SmartEditCustomOperation, SmartEditOperation } from '../../AdaptableOptions/EditOptions';
 export declare class SmartEditApiImpl extends ApiBase implements SmartEditApi {
-    setSmartEditOperation(mathOperation: SmartEditOperation): void;
+    setSmartEditOperation(mathOperation: MathOperation): void;
     getSmartEditOperation(): SmartEditOperation;
     setSmartEditValue(smartEditValue: number): void;
     getSmartEditValue(): number;
     showSmartEditPopup(): void;
     applySmartEdit(gridCells: GridCell[]): void;
     getSmartEditCustomOperations(): SmartEditCustomOperation[] | undefined;
+    setCustomSmartEditOperation(customOperationName: string): void;
 }

package/src/Api/Implementation/SmartEditApiImpl.js

@@ -28,5 +28,11 @@ class SmartEditApiImpl extends ApiBase_1.ApiBase {
     getSmartEditCustomOperations() {
         return this.getEditOptions().smartEditCustomOperations;
     }
+    setCustomSmartEditOperation(customOperationName) {
+        const customOperation = this.getSmartEditCustomOperations().find((so) => so.name == customOperationName);
+        if (customOperation) {
+            this.dispatchAction(SystemRedux.SmartEditChangeOperation(customOperation));
+        }
+    }
 }
 exports.SmartEditApiImpl = SmartEditApiImpl;

package/src/Api/Implementation/TeamSharingApiImpl.d.ts

@@ -1,13 +1,15 @@
 import { ApiBase } from './ApiBase';
 import { TeamSharingApi } from '../TeamSharingApi';
-import { TeamSharingState, SharedEntity, AdaptableModule, AdaptableObject, SharedEntityConfig } from '../../types';
+import { SharedEntity, AdaptableModule, AdaptableObject, SharedEntityConfig } from '../../types';
 export declare class TeamSharingApiImpl extends ApiBase implements TeamSharingApi {
-    getTeamSharingState(): TeamSharingState;
-    getSharedEntities(): SharedEntity[];
+    getSharedEntities(): Promise<SharedEntity[]>;
+    setSharedEntities(sharedEntities: SharedEntity[]): Promise<boolean>;
+    isTeamSharingAvailable(): boolean;
     isTeamSharingActivated(): boolean;
     hasTeamSharingFullRights(): boolean;
     checkForUpdates(): void;
     showTeamSharingPopup(): void;
     fireTeamSharingEntityChangedEvent(sharedEntity: SharedEntity): void;
     shareEntity(entity: AdaptableObject, module: AdaptableModule, sharedEntityConfig: SharedEntityConfig): void;
+    unshareEntity(entityId: string): void;
 }

package/src/Api/Implementation/TeamSharingApiImpl.js

@@ -8,20 +8,31 @@ const TeamSharingRedux_1 = require("../../Redux/ActionsReducers/TeamSharingRedux
 const TeamSharingRedux = tslib_1.__importStar(require("../../Redux/ActionsReducers/TeamSharingRedux"));
 const LoggingHelper_1 = require("../../Utilities/Helpers/LoggingHelper");
 class TeamSharingApiImpl extends ApiBase_1.ApiBase {
-    getTeamSharingState() {
-        return this.getAdaptableState().TeamSharing;
+    async getSharedEntities() {
+        if (!this.isTeamSharingActivated()) {
+            LoggingHelper_1.ConsoleLogWarning('Team Sharing is not Activated so Entities cannot be loaded');
+            return [];
+        }
+        return this.adaptable.adaptableOptions.teamSharingOptions.getSharedEntities(this.adaptable.adaptableOptions.adaptableId);
     }
-    getSharedEntities() {
-        return this.getAdaptableState().TeamSharing.SharedEntities;
+    async setSharedEntities(sharedEntities) {
+        if (!this.isTeamSharingActivated()) {
+            LoggingHelper_1.ConsoleLogWarning('Team Sharing is not Activated so Entities cannot be shared');
+            return false;
+        }
+        await this.adaptable.adaptableOptions.teamSharingOptions.setSharedEntities(this.adaptable.adaptableOptions.adaptableId, sharedEntities);
+        return true;
     }
-    isTeamSharingActivated() {
+    isTeamSharingAvailable() {
+        var _a, _b, _c;
         return (!this.getAdaptableApi()
             .internalApi.getEntitlementService()
-            .isModuleHiddenEntitlement(ModuleConstants.TeamSharingModuleId) &&
-            this.adaptable.adaptableOptions.teamSharingOptions &&
-            this.adaptable.adaptableOptions.teamSharingOptions.enableTeamSharing &&
-            !!this.adaptable.adaptableOptions.teamSharingOptions.getSharedEntities &&
-            !!this.adaptable.adaptableOptions.teamSharingOptions.setSharedEntities);
+            .isModuleHiddenEntitlement(ModuleConstants.TeamSharingModuleId) && ((_a = this.adaptable.adaptableOptions.teamSharingOptions) === null || _a === void 0 ? void 0 : _a.enableTeamSharing) &&
+            !!((_b = this.adaptable.adaptableOptions.teamSharingOptions) === null || _b === void 0 ? void 0 : _b.getSharedEntities) &&
+            !!((_c = this.adaptable.adaptableOptions.teamSharingOptions) === null || _c === void 0 ? void 0 : _c.setSharedEntities));
+    }
+    isTeamSharingActivated() {
+        return this.isTeamSharingAvailable();
     }
     hasTeamSharingFullRights() {
         return this.adaptable.api.internalApi
@@ -50,5 +61,12 @@ class TeamSharingApiImpl extends ApiBase_1.ApiBase {
         }
         this.dispatchAction(TeamSharingRedux.TeamSharingShare(entity, module, sharedEntityConfig));
     }
+    unshareEntity(entityId) {
+        if (!this.isTeamSharingActivated()) {
+            LoggingHelper_1.ConsoleLogWarning('Team Sharing is not Activated so Entities cannot be unshared');
+            return;
+        }
+        this.dispatchAction(TeamSharingRedux.TeamSharingRemoveItem(entityId));
+    }
 }
 exports.TeamSharingApiImpl = TeamSharingApiImpl;

package/src/Api/Implementation/UserInterfaceApiImpl.d.ts

@@ -24,6 +24,6 @@ export declare class UserInterfaceApiImpl extends ApiBase implements UserInterfa
     addContextMenuItem(userMenuItem: UserMenuItem<ContextMenuContext>): void;
     getEditableCellStyle(): AdaptableStyle | undefined;
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
-    getAllActionColumn(): ActionColumn[];
     getAdaptableObjectTags(): AdaptableObjectTag[] | undefined;
+    getAllActionColumn(): ActionColumn[];
 }

package/src/Api/Implementation/UserInterfaceApiImpl.js

@@ -150,10 +150,6 @@ class UserInterfaceApiImpl extends ApiBase_1.ApiBase {
     getReadOnlyCellStyle() {
         return this.getUserInterfaceOptions().readOnlyCellStyle;
     }
-    getAllActionColumn() {
-        var _a;
-        return (_a = this.getUserInterfaceOptions().actionColumns) !== null && _a !== void 0 ? _a : [];
-    }
     getAdaptableObjectTags() {
         const objectTags = this.getUserInterfaceOptions().objectTags;
         if (objectTags != null && typeof objectTags === 'function') {
@@ -166,5 +162,9 @@ class UserInterfaceApiImpl extends ApiBase_1.ApiBase {
             }
         }
     }
+    getAllActionColumn() {
+        var _a, _b;
+        return (_b = (_a = this.getUserInterfaceOptions().actionOptions) === null || _a === void 0 ? void 0 : _a.actionColumns) !== null && _b !== void 0 ? _b : [];
+    }
 }
 exports.UserInterfaceApiImpl = UserInterfaceApiImpl;

package/src/Api/InternalApi.d.ts

@@ -17,7 +17,7 @@ import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
 import { Layout } from '../PredefinedConfig/LayoutState';
 import { AdaptableAlert, AdaptableCellChangedAlert, AdaptableRowChangedAlert } from '../PredefinedConfig/Common/AdaptableAlert';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
-import { AdaptableMessageType, AlertDefinition, BaseContext, CellDataChangedInfo, EditLookUpPermittedValues, LayoutAssociatedObject, SystemStatusMessageInfo } from '../types';
+import { AdaptableIcon, AdaptableMessageType, AlertDefinition, BaseContext, CellDataChangedInfo, EditLookUpPermittedValues, LayoutAssociatedObject, SharedEntity, SystemStatusMessageInfo } from '../types';
 import { IEntitlementService } from '../Utilities/Services/Interface/IEntitlementService';
 import { AdaptableFlashingCell } from '../PredefinedConfig/Common/AdaptableFlashingCell';
 import { IQueryLanguageService } from '../Utilities/Services/Interface/IQueryLanguageService';
@@ -117,9 +117,10 @@ export interface InternalApi {
     getLabelForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getTooltipForButton(button: AdaptableButton<BaseContext>, context: BaseContext): string | undefined;
     getStyleForButton(button: AdaptableButton<BaseContext>, context: BaseContext): ButtonStyle | undefined;
+    getIconForButton(button: AdaptableButton<BaseContext>, context: BaseContext): AdaptableIcon | undefined;
     dispatchReduxAction(action: Action): void;
     waitForTeamSharingImportEnd(): Promise<boolean>;
-    getUserDefinedHeaderName(columnId: string): string;
+    getLocalTeamSharingEntities(): SharedEntity[];
     createFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar' | string): void;
     destroyFrameworkComponent(containerDomNode: HTMLElement, frameworkComponent: AdaptableFrameworkComponent, componentType: 'toolPanel' | 'toolbar' | string): void;
     initializeDataChangeHistory(): void;

package/src/Api/LayoutApi.d.ts

@@ -1,4 +1,5 @@
-import { AdaptableColumn, ColumnSort, LayoutAssociatedObject } from '../../types';
+import { RowNode } from '@ag-grid-community/all-modules';
+import { AdaptableColumn, ColumnFilter, ColumnSort, LayoutAssociatedObject } from '../../types';
 import { LayoutState, Layout } from '../PredefinedConfig/LayoutState';
 /**
  * Provides run-time access to the Layout Module and associated state
@@ -187,4 +188,90 @@ export interface LayoutApi {
      * @param adaptableObject object to check
      */
     isObjectAvailableInCurrentLayout(adaptableObject: LayoutAssociatedObject): boolean;
+    /**
+     * Retrieves all the Column Filters in the Column Filter State (of Predefined Config)
+     * @returns column filters
+     */
+    getAllColumnFilter(): ColumnFilter[];
+    /**
+     * Retrieves ColumnFilter by Id
+     * @param id column filter id
+     * @returns column filter
+     */
+    getColumnFilterById(id: ColumnFilter['Uuid']): ColumnFilter;
+    /**
+     * Sets Column Filters - will replace filters for existing column and leave other column filters in place
+     * @param columnFilters Column Filters to set
+     * @returns column filters
+     */
+    setColumnFilter(columnFilters: ColumnFilter[]): ColumnFilter[] | null;
+    /**
+     * Clears given Column Filter
+     * @param columnFilter Column Filter to clear
+     */
+    clearColumnFilter(columnFilter: ColumnFilter): void;
+    /**
+     * Clears Column Filter for given Column
+     * @param columnId Column for which Column Filter should be cleared
+     */
+    clearColumnFilterByColumn(columnId: string): void;
+    /**
+     * Clears Column Filters for given set of Columns
+     * @param columns Columns for which Column Filte should be cleared
+     */
+    clearColumnFilterByColumns(columns: string[]): void;
+    /**
+     * Clears all Column Filters in State
+     */
+    clearAllColumnFilter(): void;
+    /**
+     * Clears existing Column Filters and then sets the new ones
+     * @param columnFilters Column Filters to set
+     */
+    clearAndSetColumnFilter(columnFilters: ColumnFilter[]): void;
+    /**
+     * Retrieves all Column Filters for given Column
+     * @param columnId column to retrieve Column Filters for
+     * @returns column filters
+     */
+    getAllColumnFilterForColumn(columnId: string): ColumnFilter[];
+    /**
+     * Creates new Column Filter on given Column using Primary Key values
+     * @param columnId ColumnId to use
+     * @param primarykeyValues Primary Key Values to use
+     * @returns column filter
+     */
+    createColumnFilterForCell(columnId: string, primarykeyValues: any[]): ColumnFilter | null;
+    /**
+     * Retrieves description of given Column Filter
+     * @param columnFilter Column Filter to use
+     */
+    columnFilterToString(columnFilter: ColumnFilter): string;
+    /**
+     * Retrieves descriptions of given Column Filters
+     * @param columnFilters Column Filters to use
+     */
+    columnFiltersToString(columnFilters: ColumnFilter[]): string;
+    /**
+     * Calls AdapTableQL to evaluate Filter for given Row
+     * @param columnFilter Column Filter to use
+     * @param node Row Node to evaluate
+     */
+    evaluateColumnFilter(columnFilter: ColumnFilter, node: RowNode): boolean;
+    /**
+     * Removes a Column from the Current Layout
+     * @param columnId Column to remove
+     */
+    removeColumnFromCurrentLayout(columnId: string): void;
+    /**
+     * Removes a Column from all Layouts
+     * @param columnId Column to remove
+     */
+    removeColumnFromAllLayouts(columnId: string): void;
+    /**
+     * Removes a Column from a given Layout
+     * @param columnId Column to remove
+     * @param layoutName layout from which to remove Column
+     */
+    removeColumnFromLayout(columnId: string, layoutName: string): void;
 }

package/src/Api/SmartEditApi.d.ts

@@ -1,4 +1,5 @@
 import { SmartEditOperation } from '../AdaptableOptions/EditOptions';
+import { MathOperation } from '../PredefinedConfig/Common/Enums';
 import { GridCell } from '../PredefinedConfig/Selection/GridCell';
 import { SmartEditCustomOperation } from '../types';
 /**
@@ -6,10 +7,15 @@ import { SmartEditCustomOperation } from '../types';
  **/
 export interface SmartEditApi {
     /**
-     * Sets Smart Edit operation: ('Add','Subtract','Multiply','Divide'
+     * Sets (shipped) Smart Edit Operation: 'Add','Subtract','Multiply','Divide'
      * @param operation operation to run
      */
-    setSmartEditOperation(operation: SmartEditOperation): void;
+    setSmartEditOperation(operation: MathOperation): void;
+    /**
+     * Sets current Smart Edit Operation to a Custom Operation
+     * @param customOperationName name of Custom Smart Edit Operation
+     */
+    setCustomSmartEditOperation(customOperationName: string): void;
     /**
      * Gets current Smart Edit Operation
      */

package/src/Api/TeamSharingApi.d.ts

@@ -1,22 +1,30 @@
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
 import { SharedEntity } from '../PredefinedConfig/TeamSharingState';
-import { AdaptableModule, SharedEntityConfig, TeamSharingState } from '../types';
+import { AdaptableModule, SharedEntityConfig } from '../types';
 /**
  * Provides run-time access to Team Sharing Module and associated state
  */
 export interface TeamSharingApi {
     /**
-     * Retrieves Team Sharing section of State
+     * Retrieves all shared entities which are currently shared. It is an asynchronous operation as it leverages the `TeamSharingOptions.getSharedEntities(...)` method.
      */
-    getTeamSharingState(): TeamSharingState;
+    getSharedEntities(): Promise<SharedEntity[]>;
     /**
-     * Retrieves all Shared Entities in Team Sharing State
+     * Sets the shared entities which are currently shared. It is an asynchronous operation as it leverages the `TeamSharingOptions.setSharedEntities(...)` method.
+     * @param sharedEntities the shared entities
+     * @return either TRUE if the shared entities were successfully set or FALSE if the shared entities were not set
      */
-    getSharedEntities(): SharedEntity[];
+    setSharedEntities(sharedEntities: SharedEntity[]): Promise<boolean>;
     /**
      * Whether Team Sharing is Activated
+     *
+     * @deprecated use `Adaptable.isTeamSharingAvailable()` instead
      */
     isTeamSharingActivated(): boolean;
+    /**
+     * Whether Team Sharing is Available to use
+     */
+    isTeamSharingAvailable(): boolean;
     /**
      * Whether current user has full Team Sharing rights (for creating & updating shared items)
      */
@@ -41,4 +49,9 @@ export interface TeamSharingApi {
      * @param sharedEntityConfig Config info about the Sharing Actions
      */
     shareEntity(entity: AdaptableObject, module: AdaptableModule, sharedEntityConfig: SharedEntityConfig): void;
+    /**
+     * Removes an Adaptable Object from the Team Share.
+     * @param entityId the ID of the AdaptableObject to be removed from Team Share
+     */
+    unshareEntity(entityId: string): void;
 }

package/src/Api/UserInterfaceApi.d.ts

@@ -70,12 +70,12 @@ export interface UserInterfaceApi {
      * Returns Style set for ReadOnly cells
      */
     getReadOnlyCellStyle(): AdaptableStyle | undefined;
-    /**
-     * Retrieves any Action Columns (provided in User Interface Options)
-     */
-    getAllActionColumn(): ActionColumn[];
     /**
      * Retrieves any Object Tags (provided in User Interface Options)
      */
     getAdaptableObjectTags(): AdaptableObjectTag[] | undefined;
+    /**
+     * Retrieves any Action Columns (provided in User Interface Options)
+     */
+    getAllActionColumn(): ActionColumn[];
 }

package/src/PredefinedConfig/AdaptableState.d.ts

@@ -6,7 +6,6 @@ import { CalculatedColumnState } from './CalculatedColumnState';
 import { ConditionalStyleState } from './ConditionalStyleState';
 import { CustomSortState } from './CustomSortState';
 import { DashboardState } from './DashboardState';
-import { DataSourceState } from './DataSourceState';
 import { ExportState } from './ExportState';
 import { FormatColumnState } from './FormatColumnState';
 import { FreeTextColumnState } from './FreeTextColumnState';
@@ -18,7 +17,6 @@ import { ShortcutState } from './ShortcutState';
 import { TeamSharingState } from './TeamSharingState';
 import { ThemeState } from './ThemeState';
 import { ConfigState } from './ConfigState';
-import { FilterState } from './FilterState';
 import { ApplicationState } from './ApplicationState';
 import { ToolPanelState } from './ToolPanelState';
 import { QueryState } from './QueryState';
@@ -41,9 +39,7 @@ export interface AdaptablePersistentState {
     ConditionalStyle: ConditionalStyleState;
     CustomSort: CustomSortState;
     Dashboard: DashboardState;
-    DataSource: DataSourceState;
     Export: ExportState;
-    Filter: FilterState;
     FormatColumn: FormatColumnState;
     FreeTextColumn: FreeTextColumnState;
     Layout: LayoutState;

package/src/PredefinedConfig/Common/AdaptableButton.d.ts

@@ -11,13 +11,13 @@ export interface AdaptableButton<CONTEXT_TYPE extends BaseContext> extends Adapt
      */
     label?: string | ((button: AdaptableButton<CONTEXT_TYPE>, context: CONTEXT_TYPE) => string);
     /**
-     * Style for Button - can be object or function thats provides a `Style` object
+     * Style for Button - can be object or function that provides a `ButtonStyle` object
      */
     buttonStyle?: ButtonStyle | ((button: AdaptableButton<CONTEXT_TYPE>, context: CONTEXT_TYPE) => ButtonStyle);
     /**
-     * Icon to display, requires string for URL, other props are optional
+     * Icon for Button - can be object or function that provides a `AdaptableIcon` object
      */
-    icon?: AdaptableIcon;
+    icon?: AdaptableIcon | ((button: AdaptableButton<CONTEXT_TYPE>, context: CONTEXT_TYPE) => AdaptableIcon);
     /**
      * Tooltip for Button - can be string or function that provides string
      */

package/src/PredefinedConfig/Common/AdaptableColumn.d.ts

@@ -1,4 +1,8 @@
 import { AdaptableObject } from './AdaptableObject';
+/**
+ * The type of the column data
+ */
+export declare type AdaptableColumnDataType = 'String' | 'Number' | 'Boolean' | 'Date' | 'Object' | 'Unknown';
 /**
  * Base class for Adaptable Column containing most important properties
  */
@@ -14,7 +18,7 @@ export interface AdaptableColumnBase extends AdaptableObject {
     /**
      * DataType of the column
      */
-    dataType: 'String' | 'Number' | 'NumberArray' | 'Boolean' | 'Date' | 'Object' | 'Unknown';
+    dataType: AdaptableColumnDataType;
 }
 export declare const isValidOrderForColumnGroups: ({ oldColumns, newColumns, }: {
     oldColumns: AdaptableColumn[];

package/src/PredefinedConfig/Common/AdaptablePredicate.js

@@ -53,7 +53,24 @@ exports.SystemPredicateDefs = [
         icon: { text: '!IN' },
         columnScope: { DataTypes: ['String', 'Number', 'Date'] },
         moduleScope: ['filter'],
-        handler: ({ displayValue, inputs }) => inputs.length === 0 || !inputs.includes(displayValue),
+        handler: ({ inputs, column, value }) => {
+            // basically negation of IN
+            if (inputs.length === 0) {
+                return true;
+            }
+            if (column.dataType === 'Date') {
+                return inputs.some((input) => {
+                    return !isSameDay_1.default(input, value);
+                });
+            }
+            if (column.dataType === 'Number') {
+                return !inputs.includes(value);
+            }
+            if (column.dataType === 'String') {
+                return !inputs.includes(value);
+            }
+            return true;
+        },
         toString: ({ inputs }) => `Exclude (${inputs.join(', ')})`,
     },
     {