@adaptabletools/adaptable 22.1.1 → 23.0.0-canary.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "22.1.1",
+  "version": "23.0.0-canary.1",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -37,29 +37,34 @@
   ],
   "typings": "index.d.ts",
   "dependencies": {
+    "@base-ui/react": "^1.3.0",
     "@finos/fdc3": "2.1.0",
     "@infinite-table/infinite-react": "8.0.3",
+    "@tanstack/react-virtual": "^3.13.22",
+    "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
+    "cron-parser": "^4.9.0",
     "date-fns": "^4.1.0",
+    "lucide-react": "^0.563.0",
     "normalize.css": "^8.0.1",
     "re-resizable": "6.10.3",
     "react": "^18.0.0 || ^19.0.0",
-    "react-day-picker": "9.5.1",
+    "react-day-picker": "^9.14.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "react-redux": "9.2.0",
     "react-remove-scroll": "2.6.3",
-    "react-select": "5.10.1",
     "react-toastify": "9.1.3",
     "redux": "^5.0.1",
     "rxjs": "^7.4.0",
-    "tailwind-merge": "^3.3.1",
+    "tailwind-merge": "^3.5.0",
     "tinycolor2": "^1.4.2",
     "tslib": "^2.8.1",
+    "tw-animate-css": "^1.4.0",
     "udsv": "0.6.0",
     "uuid": "9.0.1"
   },
   "peerDependencies": {
-    "ag-grid-enterprise": ">=35.2.0"
+    "ag-grid-enterprise": ">=35.3.0"
   },
   "publishTimestamp": 0,
   "type": "module",

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -4,7 +4,7 @@ import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { ColumnSort } from '../AdaptableState/Common/ColumnSort';
 import { DataRowConfig, DataUpdateConfig } from '../AdaptableState/Common/DataUpdateConfig';
 import { Layout } from '../AdaptableState/LayoutState';
-import { GridCell, GridCellWithChildren, CellUpdateRequest } from '../AdaptableState/Selection/GridCell';
+import { CellUpdateRequest, GridCell, GridCellWithChildren } from '../AdaptableState/Selection/GridCell';
 import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
 import { AdaptableTheme } from '../AdaptableState/ThemeState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
@@ -237,6 +237,7 @@ export interface IAdaptable {
     autoSizeAllColumns(): void;
     setColumnSort(columnSorts: ColumnSort[]): void;
     clearColumnSort(): void;
+    getDefaultColumnWidthForCol(columnId: string): number;
     clearColumnFiltering(): void;
     clearColumnFilteringForColumns(columnIds: string[]): void;
     applyFiltering(config?: {
@@ -252,6 +253,8 @@ export interface IAdaptable {
     setAgGridQuickSearch(query: string): void;
     clearAgGridQuickSearch(): void;
     setAgGridFindSearchValue(searchText: string): void;
+    applyQuickSearchFindCssVars(): void;
+    refreshAgGridFind(): void;
     canGenerateCharts(): boolean;
     canDisplaySparklines(): boolean;
     showCharts(charts: ChartDefinition[]): ChartRef[];
@@ -279,7 +282,7 @@ export interface IAdaptable {
     getAgGridContainerElement(): HTMLElement | null;
     updateColumnModelAndRefreshGrid(): void;
     getAgGridColumnForColumnId(columnId: string): Column;
-    getMinMaxCachedValueForColumn(column: AdaptableColumn, minMax: 'min' | 'max'): number | undefined;
+    getMinMaxCachedValueForColumn(column: AdaptableColumn, aggregation: 'min' | 'max' | 'avg' | 'median'): number | undefined;
     destroy(config?: DestroyConfig): void;
     updateLayoutInManagerAfterStoreHasChanged(layout?: Layout): void;
     canExportToExcel(): boolean;

package/src/AdaptableOptions/ActionColumnOptions.d.ts

@@ -1,6 +1,10 @@
 import { IRowNode } from 'ag-grid-enterprise';
 import { RowScope } from '../AdaptableState/Common/RowScope';
 import { AdaptableButton, BaseContext } from '../types';
+/**
+ * How action column buttons are laid out in the cell
+ */
+export type ActionColumnDisplayMode = 'buttons' | 'dropdown';
 /**
  * Options related to Action Columns in AdapTable
  */
@@ -62,9 +66,31 @@ export interface ActionColumnContext<TData = any> extends BaseContext {
  */
 export interface ActionColumnSettings {
     /**
-     * Preferred width (in pixels) for Column; if unset, calculated dynamically by AG Grid
+     * Preferred width (in pixels) for Column; takes precedence over `autoWidth` and `minWidth`
      */
     width?: number;
+    /**
+     * Minimum width (in pixels) for the column; also used as the column width when `autoWidth` is false
+     */
+    minWidth?: number;
+    /**
+     * When true, estimates column width from button labels/icons (or dropdown label) at setup time.
+     * Dynamic labels and icons (functions) are not measured — set `width` explicitly in those cases.
+     * @defaultValue false
+     */
+    autoWidth?: boolean;
+    /**
+     * How buttons are rendered in the column.
+     * In `'dropdown'` mode, per-button `buttonStyle` and `iconPosition` are ignored;
+     * the trigger uses fixed styling and menu items use the standard list layout (icon, then label).
+     * @defaultValue 'buttons'
+     */
+    displayMode?: ActionColumnDisplayMode;
+    /**
+     * Label on the dropdown trigger when `displayMode` is `'dropdown'`
+     * @defaultValue 'Actions'
+     */
+    dropdownLabel?: string;
     /**
      * Whether Column can be resized (by dragging column header edges)
      * @defaultValue true

package/src/AdaptableOptions/ChartingOptions.d.ts

@@ -10,6 +10,13 @@ export interface ChartingOptions {
      * @noCodeItem
      */
     saveChartBehaviour?: SaveChartBehaviour;
+    /**
+     * Opens persisted AG Grid charts when AdapTable is ready.
+     * - `true` or `'all'`: all charts in `Charting.ChartDefinitions`
+     * - `string[]`: chart names to open (matches each definition's `Name` property)
+     * @defaultValue undefined (no charts opened automatically)
+     */
+    restoreChartsOnReady?: boolean | 'all' | string[];
     /**
      * Locations to display saved Charts
      */

package/src/AdaptableOptions/ColumnMenuOptions.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableColumnMenuItemName, AdaptableMenuItem, AgGridMenuItem, ColumnMenuContext, MenuSeparator } from '../AdaptableState/Common/Menu';
 import { AdaptableIcon } from '../types';
+import { MenuItemFrameworkComponent } from '../agGrid/AdaptableFrameworkComponent';
 /**
  * Options for managing menus in AdapTable – provided using 2 collections
  */
@@ -91,6 +92,35 @@ export interface UserColumnMenuItem {
      * Array of Menu Items, enabling limitless levels of menus
      */
     subMenuItems?: CustomColumnMenuItem[];
+    /**
+     * Optional Framework Component (React, Angular or Vue) used to render the
+     * content of this menu item.
+     *
+     * When supplied, AG Grid renders the component inside the menu row using
+     * its own framework adapter. The component receives AG Grid's
+     * `CustomMenuItemProps`, with the AdapTable-specific extras
+     * (`adaptableApi`, `menuContext`, plus anything passed via
+     * `menuItemParams`) available as `props.menuItemParams`.
+     *
+     * Supported in the React, Vue and Angular variants of AdapTable.
+     *
+     * For Vue, supply a factory that returns the Vue Component (NOT a render
+     * call), e.g. `({ adaptableApi }) => MyMenuItem`. AG Grid Vue then
+     * instantiates the component using its own framework adapter and passes
+     * `name`, `icon`, `menuItemParams`, ... as props.
+     *
+     * For Angular, supply `{ type: MyMenuItemComponent }` where the component
+     * implements `IMenuItemAngularComp` (with `agInit(params)` to receive
+     * `params.menuItemParams.adaptableApi` and `params.menuItemParams.menuContext`).
+     * The `onSetup` callback on `AngularFrameworkComponent` is NOT honoured
+     * for menu items because AG Grid owns the component lifecycle.
+     */
+    frameworkComponent?: MenuItemFrameworkComponent<ColumnMenuContext>;
+    /**
+     * Extra parameters passed through to the Framework Component (alongside
+     * `adaptableApi` and `menuContext`).
+     */
+    menuItemParams?: Record<string, unknown>;
 }
 /**
  * Defines AG Grid Column Menu Items

package/src/AdaptableOptions/ContextMenuOptions.d.ts

@@ -1,6 +1,7 @@
 import { MenuSeparator } from '@infinite-table/infinite-react';
 import { AdaptableContextMenuItemName, AdaptableMenuItem, AgGridMenuItem, ContextMenuContext } from '../AdaptableState/Common/Menu';
 import { AdaptableIcon } from '../types';
+import { MenuItemFrameworkComponent } from '../agGrid/AdaptableFrameworkComponent';
 /**
  * Options for managing menus in AdapTable – provided using 2 collections
  */
@@ -86,6 +87,35 @@ export interface UserContextMenuItem {
      * Array of Menu Items, enabling limitless levels of menus
      */
     subMenuItems?: CustomContextMenuItem[];
+    /**
+     * Optional Framework Component (React, Angular or Vue) used to render the
+     * content of this menu item.
+     *
+     * When supplied, AG Grid renders the component inside the menu row using
+     * its own framework adapter. The component receives AG Grid's
+     * `CustomMenuItemProps`, with the AdapTable-specific extras
+     * (`adaptableApi`, `menuContext`, plus anything passed via
+     * `menuItemParams`) available as `props.menuItemParams`.
+     *
+     * Supported in the React, Vue and Angular variants of AdapTable.
+     *
+     * For Vue, supply a factory that returns the Vue Component (NOT a render
+     * call), e.g. `({ adaptableApi }) => MyMenuItem`. AG Grid Vue then
+     * instantiates the component using its own framework adapter and passes
+     * `name`, `icon`, `menuItemParams`, ... as props.
+     *
+     * For Angular, supply `{ type: MyMenuItemComponent }` where the component
+     * implements `IMenuItemAngularComp` (with `agInit(params)` to receive
+     * `params.menuItemParams.adaptableApi` and `params.menuItemParams.menuContext`).
+     * The `onSetup` callback on `AngularFrameworkComponent` is NOT honoured
+     * for menu items because AG Grid owns the component lifecycle.
+     */
+    frameworkComponent?: MenuItemFrameworkComponent<ContextMenuContext>;
+    /**
+     * Extra parameters passed through to the Framework Component (alongside
+     * `adaptableApi` and `menuContext`).
+     */
+    menuItemParams?: Record<string, unknown>;
 }
 /**
  * Defines AG Grid Context Menu Items

package/src/AdaptableOptions/DashboardOptions.d.ts

@@ -2,6 +2,7 @@ import { AdaptableButton } from '../AdaptableState/Common/AdaptableButton';
 import { DashboardState } from '../AdaptableState/DashboardState';
 import { BaseContext, CustomRenderContext } from '../types';
 import { AdaptableFrameworkComponent } from '../agGrid/AdaptableFrameworkComponent';
+import { AdaptableForm, AdaptableFormData, AdaptableFormErrors } from '../AdaptableState/Common/AdaptableForm';
 /**
  * Options related to the Dashboard in Adaptable.
  */
@@ -36,9 +37,14 @@ export interface DashboardOptions {
     buttonsLocation?: DashboardButtonsLocation;
 }
 /**
- * Custom Toolbar (which AdapTable will manage) enabling devs to populate Dashboard with bepoke content
+ * Custom Toolbar (which AdapTable will manage) enabling devs to populate
+ * Dashboard with bespoke content.
+ *
+ * @typeParam TData - Optional shape of the toolbar form's data. Defaults to
+ *                    {@link AdaptableFormData}; declare a stricter shape
+ *                    here for fully-typed `formData` in callbacks.
  */
-export interface CustomToolbar {
+export interface CustomToolbar<TData extends AdaptableFormData = AdaptableFormData> {
     /**
      * How Toolbar is referenced (e.g. in Dashboard Popup when managing toolbars)
      */
@@ -55,6 +61,27 @@ export interface CustomToolbar {
      * Optional set of buttons to show in the Toolbar
      */
     toolbarButtons?: AdaptableButton<CustomToolbarButtonContext>[];
+    /**
+     * Optional inline form to render in the Toolbar (e.g. selects, checkboxes,
+     * inputs).
+     *
+     * Use this when you want to expose interactive controls - rather than just
+     * buttons - in your Custom Toolbar without resorting to bespoke `render`
+     * or `frameworkComponent` content.
+     *
+     * The form's `fields` are rendered side-by-side using the `inline` form
+     * layout. When the user changes any value the {@link onToolbarFormChange}
+     * callback is invoked. Buttons declared on the form receive a
+     * {@link CustomToolbarFormContext} which includes the current `formData`.
+     */
+    toolbarForm?: AdaptableForm<CustomToolbarFormContext<TData>, TData>;
+    /**
+     * Callback invoked whenever the user changes a value in the toolbar form
+     *
+     * @param formData The latest form data, keyed by field `name`
+     * @param context  Adaptable context, including the hosting Custom Toolbar
+     */
+    onToolbarFormChange?: (formData: TData, context: CustomToolbarFormContext<TData>) => void;
     /**
      * Function to provide custom content when NOT using a Framework wrapper
      */
@@ -82,6 +109,33 @@ export interface CustomToolbarButtonContext extends DashboardButtonContext {
      */
     customToolbar: CustomToolbar;
 }
+/**
+ * Context provided to {@link CustomToolbar.onToolbarFormChange} and to any
+ * Adaptable Buttons declared on a {@link CustomToolbar.toolbarForm}.
+ *
+ * It extends {@link CustomToolbarButtonContext} with the current `formData`
+ * value, the form's overall validity (`formIsValid`) and any per-field
+ * validation errors (`formErrors`), so handlers can react to - or gate on -
+ * the current state of the controls rendered in the toolbar.
+ */
+export interface CustomToolbarFormContext<TData extends AdaptableFormData = AdaptableFormData> extends CustomToolbarButtonContext {
+    /**
+     * Current values of the form fields, keyed by field `name`. Strongly
+     * typed as `TData` when the hosting `CustomToolbar` supplies an explicit
+     * data shape.
+     */
+    formData: TData;
+    /**
+     * `true` when every (non-hidden) field's value satisfies its validation
+     * rules (`required`, `min`, `max`, `pattern`, custom `validate`).
+     */
+    formIsValid: boolean;
+    /**
+     * Per-field validation errors keyed by field `name`. Empty when the form
+     * is valid.
+     */
+    formErrors: AdaptableFormErrors;
+}
 /**
  * Where Dashboard Buttons are displayed
  */

package/src/AdaptableOptions/DefaultAdaptableOptions.js

@@ -1,5 +1,5 @@
 import * as GeneralConstants from '../Utilities/Constants/GeneralConstants';
-import UIHelper, { getHexForName, GRAY, GREEN, RED } from '../View/UIHelper';
+import { getGraySwatchColor, getSwatchColorVar } from '../View/UIHelper';
 import { ACCESS_LEVEL_FULL, EMPTY_STRING, EMPTY_ARRAY, DEFAULT_DATE_FORMAT_PATTERN_WITH_TIME, SYSTEM_REPORT_NAMES, SYSTEM_REPORT_FORMATS, SYSTEM_EXPORT_DESTINATIONS, } from '../Utilities/Constants/GeneralConstants';
 import { SystemAlertPredicateIds, SystemBadgeStylePredicateIds, SystemFilterPredicateIds, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateIds, } from '../AdaptableState/Common/AdaptablePredicate';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
@@ -94,9 +94,15 @@ const DefaultAdaptableOptions = {
         validateOnServer: undefined,
         displayServerValidationMessages: true,
         isCellEditable: undefined,
-        smartEditCustomOperations: undefined,
+        smartEditOptions: {
+            customOperations: undefined,
+        },
         customEditColumnValues: undefined,
         showSelectCellEditor: undefined,
+        plusMinusOptions: {
+            incrementKey: '+',
+            decrementKey: '-',
+        },
     },
     entitlementOptions: {
         defaultAccessLevel: ACCESS_LEVEL_FULL,
@@ -190,13 +196,13 @@ const DefaultAdaptableOptions = {
         defaultFlashDuration: 500,
         defaultFlashTarget: 'cell',
         defaultDownChangeStyle: {
-            BackColor: getHexForName(RED),
+            BackColor: getSwatchColorVar(18), // red by default (for flashing down changes)
         },
         defaultUpChangeStyle: {
-            BackColor: getHexForName(GREEN),
+            BackColor: getSwatchColorVar(7), // green by default (for flashing up changes)    
         },
         defaultNeutralChangeStyle: {
-            BackColor: getHexForName(GRAY),
+            BackColor: getGraySwatchColor(),
         },
     },
     formatColumnOptions: {
@@ -322,7 +328,6 @@ const DefaultAdaptableOptions = {
             showOutsideDays: true,
             datepickerButtons: ['close', 'today'],
         },
-        colorPalette: UIHelper.getDefaultColors(),
         editableCellStyle: undefined,
         readOnlyCellStyle: undefined,
         editedCellStyle: undefined,
@@ -375,6 +380,8 @@ export function applyDefaultAdaptableOptions(adaptableOptions) {
     adaptableOptsWithDefaults.dataSetOptions = Object.assign({}, DefaultAdaptableOptions.dataSetOptions, adaptableOptions.dataSetOptions);
     // edit options
     adaptableOptsWithDefaults.editOptions = Object.assign({}, DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
+    adaptableOptsWithDefaults.editOptions.plusMinusOptions = Object.assign({}, DefaultAdaptableOptions.editOptions.plusMinusOptions, adaptableOptsWithDefaults.editOptions.plusMinusOptions);
+    adaptableOptsWithDefaults.editOptions.smartEditOptions = Object.assign({}, DefaultAdaptableOptions.editOptions.smartEditOptions, adaptableOptsWithDefaults.editOptions.smartEditOptions);
     // entitlement options
     adaptableOptsWithDefaults.entitlementOptions = Object.assign({}, DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
     // export options

package/src/AdaptableOptions/EditOptions.d.ts

@@ -20,10 +20,6 @@ export interface EditOptions<TData = any> {
      * Function which checks if a given Grid Cell is editable
      */
     isCellEditable?: (cellEditableContext: CellEditableContext<TData>) => boolean;
-    /**
-     * Custom Operations to use in Smart Edit
-     */
-    smartEditCustomOperations?: SmartEditCustomOperation<TData>[];
     /**
      * Columns that will display a Select dropdown when editing
      */
@@ -32,6 +28,14 @@ export interface EditOptions<TData = any> {
      * List of Column values to display when Editing (i.e. in Edit Lookups, Bulk Update)
      */
     customEditColumnValues?: (context: CustomEditColumnValuesContext<TData>) => CustomEditColumnValueInfo[] | Promise<CustomEditColumnValueInfo[]>;
+    /**
+     * Options for Plus Minus module (keyboard increment / decrement)
+     */
+    plusMinusOptions?: PlusMinusOptions;
+    /**
+     * Options for Smart Edit module
+     */
+    smartEditOptions?: SmartEditOptions<TData>;
 }
 /**
  * Context used when getting Distinct Column Values for Editing
@@ -140,3 +144,29 @@ export interface CellEditableContext<TData = any> extends BaseContext {
      */
     defaultColDefEditableValue: boolean;
 }
+/**
+ * Options for editing-based Plus Minus Module
+ */
+export interface PlusMinusOptions {
+    /**
+     * Key that increases cell value for nudges (if not overriden in a Plus Minus Rule)
+     *
+     * @defaultValue '+'
+     */
+    incrementKey?: string;
+    /**
+     * Key that decreases cell value for nudges (if not overriden in a Plus Minus Rule)
+     *
+     * @defaultValue '-'
+     */
+    decrementKey?: string;
+}
+/**
+ * Options for editing-based Smart Edit Module
+ */
+export interface SmartEditOptions<TData = any> {
+    /**
+     * Custom Operations to use in Smart Edit
+     */
+    customOperations?: SmartEditCustomOperation<TData>[];
+}

package/src/AdaptableOptions/NotificationsOptions.d.ts

@@ -6,7 +6,7 @@ export interface NotificationsOptions {
      * How many Notifications can be displayed at one time
      *
      * @defaultValue  3
-     * noCodeItem
+     * @noCodeItem
      */
     maxNotifications?: number;
     /**

package/src/AdaptableOptions/RowFormOptions.d.ts

@@ -1,5 +1,5 @@
 import { IRowNode } from 'ag-grid-enterprise';
-import { RowFormSubmittedInfo, AdaptableButton, AdaptableColumn, BaseContext, FormContext } from '../types';
+import { RowFormSubmittedInfo, AdaptableButton, AdaptableColumn, AdaptableFormField, BaseContext, FormContext } from '../types';
 /**
  * Options related to Dynamic Row Forms in AdapTable
  */
@@ -30,10 +30,54 @@ export interface RowFormOptions<TData = any> {
      */
     rowFormDescription?: string | ((context: RowFormTitleContext<TData>) => string);
     /**
-     * Custom form field label provider
+     * Custom form field label provider.
+     *
+     * Superseded by {@link rowFormField} (which can return any subset of
+     * {@link AdaptableFormField} properties, including `label`); kept for
+     * backward compatibility.
      * @defaultValue undefined
      */
     rowFormFieldLabel?: (context: RowFormFieldContext<TData>) => string;
+    /**
+     * Per-column override for the auto-built {@link AdaptableFormField}.
+     *
+     * Return any subset of `AdaptableFormField` properties to customise the
+     * field for a particular column. Anything you don't return falls back to
+     * AdapTable's default - which is derived from the column's data type
+     * (string → `text`, number → `number`, boolean → `checkbox`, date →
+     * `date`, columns with discrete options → `select`).
+     *
+     * Returning `undefined` keeps the default field for that column.
+     *
+     * Use this to unlock the full power of {@link AdaptableFormField} in
+     * Row Forms - including:
+     * - presentation (`placeholder`, `helpText`, `tooltip`)
+     * - validation (`required`, `min`, `max`, `pattern`, `validate`)
+     * - data-driven `hidden` / `disabled`
+     * - alternative field types (`textarea`, `radio`, `slider`, `time`,
+     *   `datetime`, `color`)
+     * - multi-select via `multi: true`
+     * - bespoke widgets via `fieldType: 'custom'` + `render`
+     *
+     * @example
+     * ```ts
+     * rowFormField: ({ column }) => {
+     *   if (column.columnId === 'notes') {
+     *     return { fieldType: 'textarea', rows: 4, placeholder: 'optional notes' };
+     *   }
+     *   if (column.columnId === 'email') {
+     *     return {
+     *       required: true,
+     *       pattern: '^\\S+@\\S+\\.\\S+$',
+     *       helpText: 'we will only use this for delivery',
+     *     };
+     *   }
+     * }
+     * ```
+     *
+     * @defaultValue undefined
+     */
+    rowFormField?: (context: RowFormFieldContext<TData>) => Partial<AdaptableFormField> | undefined;
     /**
      * Custom form buttons; if provided, need to handle form submission explicitly
      */

package/src/AdaptableOptions/UserInterfaceOptions.d.ts

@@ -29,9 +29,9 @@ export interface UserInterfaceOptions<TData = any> {
      */
     dateInputOptions?: DateInputOptions;
     /**
-     * Colours to display in Colour Picker (in place of AdapTable's default set); can be hardcoded list or function
-     *
-     * @defaultValue default colors provided by AdapTable
+     * @deprecated Override `--ab-color-swatch-*`, `--ab-color-palette-*`, and semantic
+     * `--ab-color-*` variables in your light or dark theme CSS instead. Will be removed in a
+     * future major release.
      */
     colorPalette?: string[] | ((currentTheme: string) => string[]);
     /**

package/src/AdaptableState/AdaptableState.d.ts

@@ -8,7 +8,6 @@ import { ExportState } from './ExportState';
 import { FormatColumnState } from './FormatColumnState';
 import { FreeTextColumnState } from './FreeTextColumnState';
 import { LayoutState } from './LayoutState';
-import { ScheduleState } from './ScheduleState';
 import { PlusMinusState } from './PlusMinusState';
 import { QuickSearchState } from './QuickSearchState';
 import { ShortcutState } from './ShortcutState';
@@ -50,7 +49,6 @@ export interface AdaptablePersistentState {
     Note: NoteState;
     PlusMinus: PlusMinusState;
     QuickSearch: QuickSearchState;
-    Schedule: ScheduleState;
     Shortcut: ShortcutState;
     StatusBar: StatusBarState;
     StyledColumn: StyledColumnState;