@adaptabletools/adaptable 20.3.0-canary.2 → 21.0.0-canary.0

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

@@ -1,5 +1,7 @@
 import { AdaptableObject } from './AdaptableObject';
 import { BaseCellDataType, ColDef } from 'ag-grid-enterprise';
+import { UniqueGridCell } from '../Selection/GridCell';
+import { ColumnFilter } from './ColumnFilter';
 /**
  * Defines data type of a Column; can be an AG Grid BaseCellDataType or an AdapTable array-related one
  */
@@ -210,3 +212,8 @@ export interface AdaptableColumnProperties {
     pivotable: boolean;
     aggregatable: boolean;
 }
+export interface AdaptableColumnSummary {
+    column: AdaptableColumn;
+    columnFilter: ColumnFilter;
+    uniqueGridCells: UniqueGridCell[];
+}

package/src/AdaptableState/Common/AdaptablePredicate.js

@@ -51,7 +51,7 @@ export const SystemPredicateDefs = [
             }
             if (column.dataType === 'date') {
                 return inputs.some((input) => {
-                    if (adaptableApi.optionsApi.getPredicateOptions().evaluateValuesPredicateUsingTime) {
+                    if (adaptableApi.optionsApi.getPredicateOptions().evaluateInPredicateUsingTime) {
                         return isEqual(input, value);
                     }
                     else {
@@ -125,7 +125,7 @@ export const SystemPredicateDefs = [
                 return true;
             }
             if (column.dataType === 'date') {
-                if (adaptableApi.optionsApi.getPredicateOptions().evaluateValuesPredicateUsingTime) {
+                if (adaptableApi.optionsApi.getPredicateOptions().evaluateInPredicateUsingTime) {
                     return inputs.every((input) => {
                         return !isEqual(input, value);
                     });

package/src/AdaptableState/Common/CustomWindowConfig.d.ts

@@ -1,51 +1,51 @@
 import { AdaptableSystemIconName } from '../../types';
 import { CustomRenderContext, AdaptableFrameworkComponent } from '../../agGrid/AdaptableFrameworkComponent';
 /**
- * Config used to open a custom window
+ * Config used to open a Custom Window
  */
 export interface CustomWindowConfig {
     /**
-     * Unique identifier for the custom window.
+     * Unique identifier for Custom Window
      */
     id: string;
     /**
-     * Title of the custom window.
+     * Title of Custom Window
      */
     title?: string;
     /**
-     * Icon to display in the custom window heading.
+     * Icon to display in Custom Window header
      */
     icon?: AdaptableSystemIconName;
     /**
-     * Render function to display custom content in the window (if not using a framework component).
+     * Render function to display content in Custom Window (if not using a framework component)
      */
     render?: (customRenderContext: CustomRenderContext) => string | null;
     /**
-     * A React, Angular or Vue Framework component to use for the custom window content.
+     * React, Angular or Vue Framework component to use for Custom Window content
      */
     frameworkComponent?: AdaptableFrameworkComponent;
     /**
-     * Callback function to be called when the framework component is destroyed.
+     * Callback function invoked when framework component is destroyed
      */
     onFrameworkComponentDestroyed?: () => void;
     /**
-     * Window position in pixels.
+     * Size of window in pixels (provided as width, height)
      */
     size?: WindowSize;
     /**
-     * Position of the window in pixels.
+     * Position of window in pixels (provided as x, y)
      */
     position?: WindowPosition;
 }
 /**
- * Defines size of a custom window
+ * Defines size of a Custom Window
  */
 export interface WindowSize {
     width: number;
     height: number;
 }
 /**
- * Defines position of a custom window
+ * Defines position of a Custom Window
  */
 export interface WindowPosition {
     x: number;

package/src/AdaptableState/Common/ExtendedLayout.d.ts

@@ -0,0 +1,50 @@
+import { Layout } from '../LayoutState';
+import { AlertDefinition } from '../AlertState';
+import { CustomSort } from '../CustomSortState';
+import { FlashingCellDefinition } from '../FlashingCellState';
+import { FormatColumn } from '../FormatColumnState';
+import { PlusMinusNudge } from '../PlusMinusState';
+import { Shortcut } from '../ShortcutState';
+import { StyledColumn } from '../StyledColumnState';
+import { BaseSchedule } from './Schedule';
+/**
+ * Defines an Extended Layout - provides a Layout and all objects that refer to it
+ */
+export interface ExtendedLayout {
+    /**
+     * Layout being extended
+     */
+    Layout: Layout;
+    /**
+     * Object to be included in the Layout
+     */
+    Extensions: LayoutExtension[];
+}
+/**
+ * Defines an object being extended in a Layout
+ */
+export interface LayoutExtension {
+    /**
+     * Module to which Extended Object belongs
+     */
+    Module: LayoutExtensionModule;
+    /**
+     * Object being Extended
+     */
+    Object: LayoutExtensionObject;
+}
+/**
+ * Types of Adaptable Objects that can added to Extended Layouts
+ */
+export type LayoutExtensionObject = AlertDefinition | CustomSort | FlashingCellDefinition | FormatColumn | PlusMinusNudge | StyledColumn | Shortcut | BaseSchedule;
+/**
+ * Modules which can provide objects in Extended Layouts
+ */
+export type LayoutExtensionModule = 'Alert' | 'CustomSort' | 'FlashingCell' | 'FormatColumn' | 'FreeTextColumn' | 'PlusMinus' | 'Schedule' | 'Shortcut' | 'StyledColumn';
+/**
+ * Configuration for API methods which load objects that can be Layout extensions
+ */
+export interface LayoutExtendedConfig {
+    includeLayoutNotExtendedObjects?: boolean;
+    extendedLayoutName?: string;
+}

package/src/AdaptableState/Common/ProgressIndicatorConfig.d.ts

@@ -17,10 +17,7 @@ export interface ProgressIndicatorConfig {
      */
     frameworkComponent?: AdaptableFrameworkComponent;
     /**
-     * Determines how the custom component is rendered:
-     * - "content" (default): Inside the default Dialog with spinner
-     * - "dialog": As a complete replacement for the Dialog
-     * Applies to both frameworkComponent and render parameters.
+     * Determines whether custom component is rendered as "content" (inside window) or "dialog" (replacing window)
      */
     renderMode?: 'content' | 'dialog';
     /**

package/src/AdaptableState/Common/RowScope.d.ts

@@ -15,7 +15,7 @@ export interface RowScope {
      */
     ExcludeSummaryRows?: boolean;
     /**
-     * Exclude Grand Total Rows
+     * Exclude Grand Total Rows (used in Aggregations)
      */
     ExcludeTotalRows?: boolean;
 }

package/src/AdaptableState/FormatColumnState.d.ts

@@ -6,7 +6,7 @@ import { RowScope } from './Common/RowScope';
 import { SuspendableObject } from './Common/SuspendableObject';
 import { XOR } from '../Utilities/Extensions/TypeExtensions';
 import { TypeHint } from './Common/Types';
-import { AdaptableBooleanQuery } from '../types';
+import { AdaptableBooleanQuery, LayoutExtendedConfig } from '../types';
 import { AdaptableColumnPredicate } from './Common/AdaptablePredicate';
 /**
  * Adaptable State Section for Format Column Module
@@ -26,17 +26,17 @@ export interface FormatColumn extends SuspendableObject {
      */
     Scope: ColumnScope;
     /**
-     * Which part of the Column to apply Format to: `cell`, `column header`
+     * Where in Column to apply Format (`cell` or `columnHeader`)
      *
-     * @defaultValue ['cell']
+     * @defaultValue 'cell'
      */
-    Target?: FormatColumnTarget[];
+    Target?: FormatColumnTarget;
     /**
      * Rule to decide whether to apply Format; if undefined Format is always applied
      */
     Rule?: FormatColumnRule;
     /**
-     * Style to apply
+     * AdapTable Style to apply
      */
     Style?: AdaptableStyle;
     /**
@@ -44,21 +44,21 @@ export interface FormatColumn extends SuspendableObject {
      */
     DisplayFormat?: AdaptableFormat;
     /**
-     * Aligns cells 'Left' or 'Right' or 'Center'
+     * Align cells 'Left' or 'Right' or 'Center'
      */
     CellAlignment?: CellAlignment;
     /**
-     * Which types of Rows should be formatted (data, grouped, summary)
+     * Which types of Rows to apply format (data, grouped, summary, total)
      */
     RowScope?: RowScope;
     /**
-     * When to format Columns in Column Groups ('Expanded', 'Collapsed' or 'Both')
+     * When to format Columns in Column Groups ('Expanded', 'Collapsed', 'Both')
      *
      */
     ColumnGroupScope?: ColumnGroupScope;
 }
 /**
- * Target for Format Column: Specifies which visual elements of the column receive formatting
+ * Specifies whether Column's cells or header is formatted
  */
 export type FormatColumnTarget = 'cell' | 'columnHeader';
 /**
@@ -89,3 +89,10 @@ export type SystemFormatColumnPredicateIds = SystemFormatColumnPredicateId[];
  * List of System Predicates available for Format Columns
  */
 export type SystemFormatColumnPredicateId = 'Blanks' | 'NonBlanks' | 'Equals' | 'NotEquals' | 'GreaterThan' | 'LessThan' | 'Positive' | 'Negative' | 'Zero' | 'Between' | 'NotBetween' | 'Is' | 'IsNot' | 'Contains' | 'NotContains' | 'StartsWith' | 'EndsWith' | 'Regex' | 'Today' | 'Yesterday' | 'Tomorrow' | 'ThisWeek' | 'ThisMonth' | 'ThisQuarter' | 'ThisYear' | 'InPast' | 'InFuture' | 'Before' | 'After' | 'On' | 'NotOn' | 'NextWorkDay' | 'LastWorkDay' | 'WorkDay' | 'Holiday' | 'True' | 'False' | 'In' | 'NotIn';
+/**
+ * Config for api methods that get Format Columns
+ */
+export interface FormatColumnConfig extends LayoutExtendedConfig {
+    includeSuspended?: boolean;
+    target?: FormatColumnTarget;
+}

package/src/AdaptableState/InternalState.d.ts

@@ -93,7 +93,7 @@ export interface InternalState extends IPushPullState, OpenFinState {
      * Keeps session-relevant information for Layout
      */
     Layout: {
-        ShowLayoutNotAssociatedObjects: boolean;
+        showLayoutNonExtendedObjects: boolean;
     };
     /**
      * Equivalent of `UserInterfaceOptions.disableDeleteConfirmation`

package/src/AdaptableState/LayoutState.d.ts

@@ -36,9 +36,9 @@ export interface LayoutBase extends AdaptableObject {
      */
     Name: string;
     /**
-     * Set of widths for some (or all) Columns
+     * Controls size (width or flex & min/max) for Columns
      */
-    ColumnWidths?: ColumnNumberMap;
+    ColumnSizing?: ColumnSizingMap;
     /**
      * Defines which Row Groups are expanded / collapsed
      */
@@ -79,6 +79,10 @@ export interface LayoutBase extends AdaptableObject {
      * Position of the Grand Total Row in the Layout
      */
     GrandTotalRow?: 'top' | 'bottom' | 'pinnedTop' | 'pinnedBottom' | boolean;
+    /**
+     * Display Row Grouped Columns as 'single' or 'multi' column
+     */
+    RowGroupDisplayType?: 'single' | 'multi';
 }
 /**
  * Defines a Table-based Layout
@@ -104,10 +108,6 @@ export interface TableLayout extends LayoutBase {
      * Columns which are row-grouped when the Layout is applied
      */
     RowGroupedColumns?: string[];
-    /**
-     * Display Row Grouped Columns as 'single' or 'multi' column
-     */
-    RowGroupDisplayType?: 'single' | 'multi';
     /**
      * Pivot Columns - must NOT be provided
      */
@@ -227,6 +227,12 @@ export type ColumnGroupValuesWithExceptionKeys = {
      */
     ExceptionGroupKeys?: any[];
 };
+/**
+ * Defines a map of Columns with Sizing information
+ */
+export type ColumnSizingMap = {
+    [columnId: string]: ColumnSizingDefinition;
+};
 /**
  * Defines a map of Columns with a String value
  */
@@ -251,6 +257,20 @@ export type ColumnBooleanFalseMap = {
 export type ColumnDirectionMap = {
     [columnId: string]: 'left' | 'right';
 };
+/**
+ * State & behaviour for sizing a column (must set `width` or `flex` property, but not both); all other props optional
+ */
+export type ColumnSizingDefinition = ({
+    Width?: number;
+    Flex?: never;
+} | {
+    Flex?: number;
+    Width?: never;
+}) & {
+    Resizable?: boolean;
+    MinWidth?: number;
+    MaxWidth?: number;
+};
 /**
  * The OLD Layout - kept temporarily so we can check what we previously had
  */

package/src/AdaptableState/Selection/GridCell.d.ts

@@ -55,7 +55,39 @@ export interface GridCell<TData = any> {
     isRowGroupCell: boolean;
 }
 export interface GridCellWithCount extends GridCell {
+    /**
+     * How many times Cell appears in Data Source
+     */
     count: number;
+    /**
+     * How many times Cell appears in Visible Rows
+     */
+    visibleCount?: number;
+}
+export interface UniqueGridCell<TData = any> {
+    /**
+     * Raw value of Cell
+     */
+    rawValue: any;
+    /**
+     * Normalised value of Cell
+     */
+    normalisedValue: any;
+    /**
+     * Display value of Cell (e.g. if formatted)
+     */
+    displayValue: any;
+    /**
+     * Is Cell in a currently filtered Row
+     */
+    visible: boolean;
+    /**
+     * How many times Cell appears in Data Source
+     */
+    count: number;
+    /**
+     * How many times Cell appears in filtered Rows
+     */
     visibleCount: number;
 }
 /**

package/src/AdaptableState/StyledColumnState.d.ts

@@ -1,6 +1,6 @@
 import { BaseState } from './BaseState';
 import { SuspendableObject } from './Common/SuspendableObject';
-import { AdaptableCustomIcon, AdaptableSystemIcon, AdaptablePredicate, AdaptableStyle, AdaptableBooleanQuery } from '../types';
+import { AdaptablePredicate, AdaptableStyle, AdaptableBooleanQuery, AdaptableIcon } from '../types';
 import { TypeHint } from './Common/Types';
 import { RowScope } from './Common/RowScope';
 import { AgSparklineOptions } from 'ag-charts-types';
@@ -173,7 +173,7 @@ export interface BadgeStyleDefinition {
     /**
      * Icon to display in Badge
      */
-    Icon?: AdaptableSystemIcon | AdaptableCustomIcon;
+    Icon?: AdaptableIcon;
     /**
      * Position of Icon in the Badge - 'Start' or 'End'
      */

package/src/Api/AlertApi.d.ts

@@ -1,6 +1,6 @@
 import { AlertDefinition, AlertState } from '../AdaptableState/AlertState';
 import { AdaptableAlert } from '../AdaptableState/Common/AdaptableAlert';
-import { AdaptableMessageType, AlertProperties } from '../types';
+import { AdaptableMessageType, AlertProperties, LayoutExtendedConfig } from '../types';
 import { AdaptableObjectLookupCriteria } from '../AdaptableState/Common/AdaptableObject';
 /**
  * Provides run-time access to Alert function and associated State
@@ -19,27 +19,21 @@ export interface AlertApi {
      * Retrieves all Alert Definitions in Alert State
      * @returns alert definitions
      */
-    getAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all Alert Definitions which are currently suspended
      */
-    getSuspendedAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getSuspendedAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves all Alert Definitions which are currently active
      */
-    getActiveAlertDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): AlertDefinition[];
+    getActiveAlertDefinitions(config?: LayoutExtendedConfig): AlertDefinition[];
     /**
      * Retrieves alert definition by the technical ID (from `AlertState`)
      * @param id alert definition id
      * @returns alert definition
      */
-    getAlertDefinitionById(id: AlertDefinition['Uuid']): AlertDefinition;
+    getAlertDefinitionById(id: AlertDefinition['Uuid'], config?: LayoutExtendedConfig): AlertDefinition;
     /**
      * Adds given Alert Definition to Adaptable State
      * @param alertDefinition AlertDefinition to add

package/src/Api/ColumnApi.d.ts

@@ -1,4 +1,5 @@
 import { AdaptableColumn, AdaptableColumnDataType, Layout } from '../../types';
+import { AdaptableColumnSummary } from '../AdaptableState/Common/AdaptableColumn';
 import { ColDef, ColGroupDef, Column } from 'ag-grid-enterprise';
 /**
  * Provides run-time access to AdapTable Column related features
@@ -13,7 +14,7 @@ export interface ColumnApi {
      */
     getUIAvailableColumns(): AdaptableColumn[];
     /**
-     * Returns all columns excluding Action, FreeText and Calculated Columns
+     * Returns all UI available columns excluding Action, FreeText and Calculated Columns
      */
     getNonSpecialColumns(): AdaptableColumn[];
     /**
@@ -174,6 +175,11 @@ export interface ColumnApi {
      * @param columnId ColumnId to check
      */
     isPivotResultColumn(columnId: string): boolean;
+    /**
+     * Checks if Column with given ColumnId is a Special (i.e. calculated, freetext or action) Column
+     * @param columnId ColumnId to check
+     */
+    isSpecialColumn(columnId: string): boolean;
     /**
      * Checks if Column with given ColumnId is a Calculated Column
      * @param columnId ColumnId to check
@@ -329,4 +335,14 @@ export interface ColumnApi {
      * @param columnType - Column Type to check for
      */
     hasColumnType(columnIdentifier: string | ColDef, columnType: string): boolean;
+    /**
+     * Gets summary info for a column including filters and unique values
+     * @param columnId Column to summarise
+     */
+    getColumnSummaryForColumnId(columnId: string): AdaptableColumnSummary;
+    /**
+     * Whether column is auto generated by AG Grid (for selection, grouping, pivoting etc)
+     * @param columnId column to check
+     */
+    isAgGridGeneratedColumn(columnId: string): boolean;
 }

package/src/Api/ColumnFilterApi.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate } from '../types';
+import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate, InFilterValue, InFilterValueInfo } from '../types';
 import { AdaptablePredicateDef, ColumnFilterDef } from '../AdaptableState/Common/AdaptablePredicate';
 /**
  * Provides run-time access to Filter section of Adaptable State.
@@ -122,9 +122,39 @@ export interface ColumnFilterApi {
      */
     columnFiltersToString(columnFilters: ColumnFilter[]): string;
     /**
-     * Sets the Column Filter for a given Column
+     * Sets the Column Filter for a given Column (clears any existing)
      * @param columnId - Column ID to set Column Filter for
      * @param predicate - Column Filter to set
      */
     setColumnFilterForColumn(columnId: string, predicate: ColumnFilterPredicate): void;
+    /**
+     * Adds the Blanks Predicate if any value is null, undefined or an empty string
+     * @param columnDistinctValues list to check for empty values
+     */
+    addBlanksToInFilterValues(columnDistinctValues: InFilterValueInfo[]): InFilterValueInfo[];
+    /**
+     * Refresh(reload) the filter values for a given Column (for `IN` Filter).
+     *
+     * @param columnId - the ID of the Column for which to refresh filter values.
+     * @return a Promise that resolves to the list of filter values, each represented as an object with `value` and `label` properties.
+     */
+    refreshFilterValues(columnId: string): Promise<InFilterValue[]>;
+    /**
+     * Refreshes (reloads) the filter values for ALL Columns (for `IN` Filter).
+     *
+     * @returns A Promise that resolves to a map where:
+     *          - keys are column IDs (string)
+     *          - values are arrays of filter values for the corresponding column
+     *            Each filter value contains a `value` and display `label` property
+     */
+    refreshAllFilterValues(): Promise<Record<string, InFilterValue[]>>;
+    /**
+     * Reset(clear cache) the filter values for a given Column (for `IN` Filter).
+     * @param columnId - the ID of the Column for which to reset filter values.
+     */
+    resetFilterValues(columnId: string): void;
+    /**
+     * Reset(clear cache) the filter values for ALL Columns (for `IN` Filter).
+     */
+    resetAllFilterValues(): void;
 }

package/src/Api/CustomSortApi.d.ts

@@ -1,5 +1,6 @@
 import { ColumnValuesComparer } from '../AdaptableOptions/CustomSortOptions';
 import { CustomSortState, CustomSort } from '../AdaptableState/CustomSortState';
+import { LayoutExtendedConfig } from '../types';
 /**
  *  Provides run-time access to the Custom Sort function
  */
@@ -11,15 +12,13 @@ export interface CustomSortApi {
     /**
      * Retrieves all Custom Sorts in Adaptable State
      */
-    getCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves Custom Sort by the technical ID (from `CustomSortState`)
      * @param id Custom Sort technical id
      * @returns Custom Sort
      */
-    getCustomSortById(id: CustomSort['Uuid']): CustomSort;
+    getCustomSortById(id: CustomSort['Uuid'], config?: LayoutExtendedConfig): CustomSort;
     /**
      * Retrieves all Custom Sorts in Adaptable State that are currently applied
      * @returns Custom Sorts
@@ -33,16 +32,12 @@ export interface CustomSortApi {
      * Retrieves all Custom Sorts that are active (not-suspended) in Adaptable State
      * @returns Custom Sorts
      */
-    getActiveCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getActiveCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves all Custom Sorts that are suspended in Adaptable State
      * @returns Custom Sorts
      */
-    getSuspendedCustomSorts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): CustomSort[];
+    getSuspendedCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
     /**
      * Retrieves Custom Sort from Adaptable State for Column with given ColumnId
      * @param columnId Id of Column to retrieve Custom Sort for

package/src/Api/FlashingCellApi.d.ts

@@ -3,6 +3,7 @@ import { AdaptablePredicateDef } from '../AdaptableState/Common/AdaptablePredica
 import { ColumnScope } from '../AdaptableState/Common/ColumnScope';
 import { FlashingCellDefinition, FlashingCellState } from '../AdaptableState/FlashingCellState';
 import { AdaptableObjectLookupCriteria } from '../AdaptableState/Common/AdaptableObject';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to Flashing Cell functionality and associated State
  */
@@ -15,25 +16,23 @@ export interface FlashingCellApi {
     /**
      * Retrieves all Flashing Cell Definitions in Flashing Cell State
      */
-    getFlashingCellDefinitions(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): FlashingCellDefinition[];
+    getFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Retrieves Flashing Cell Definition by the technical ID (from `FlashingCellState`)
      * @param id Flashing Cell Definition Id
      * @returns Flashing Cell Definition
      */
-    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid']): FlashingCellDefinition;
+    getFlashingCellDefinitionById(id: FlashingCellDefinition['Uuid'], config?: LayoutExtendedConfig): FlashingCellDefinition;
     /**
      * Retrieves all active (non-suspended) cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getActiveFlashingCellDefinitions(): FlashingCellDefinition[];
+    getActiveFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Retrieves all suspended Cell Definitions in Flashing Cell State
      * @returns flashing cell definitions
      */
-    getSuspendedFlashingCellDefinitions(): FlashingCellDefinition[];
+    getSuspendedFlashingCellDefinitions(config?: LayoutExtendedConfig): FlashingCellDefinition[];
     /**
      * Returns `FlashTarget` of the given Flashing Cell Definition
      * @param flashingCellDefinition Flashing Cell Definition to check
@@ -61,6 +60,11 @@ export interface FlashingCellApi {
      * @param flashingCellDefinition Flashing Cell Definition to Add
      */
     addFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): FlashingCellDefinition;
+    /**
+     * Deletes a Flashing Cell
+     * @param flashingCellDefinition flashing cell to delete
+     */
+    deleteFlashingCellDefinition(flashingCellDefinition: FlashingCellDefinition): void;
     /**
      * Sets a collection of Flashing Cell Definitions into State
      * @param flashingCellDefinitions Flashing Cell Definitions to Add to State