@osdk/react-components 0.1.0 → 0.2.0-beta.10

package/build/cjs/public/experimental.cjs

@@ -1,29 +1,2877 @@
 'use strict';
 
-var reactTable = require('@tanstack/react-table');
-var React7 = require('react');
-var react = require('@osdk/react');
-var experimental = require('@osdk/react/experimental');
+var button = require('@base-ui/react/button');
+var classnames7 = require('classnames');
+var React21 = require('react');
 var checkbox = require('@base-ui/react/checkbox');
 var icons = require('@blueprintjs/icons');
-var classNames2 = require('classnames');
+var experimental = require('@osdk/react/experimental');
+var input = require('@base-ui/react/input');
+var lodashEs = require('lodash-es');
+var combobox = require('@base-ui/react/combobox');
+var select = require('@base-ui/react/select');
+var _switch = require('@base-ui/react/switch');
+var reactTable = require('@tanstack/react-table');
+var react = require('@osdk/react');
+var collapsible = require('@base-ui/react/collapsible');
+var sortable = require('@dnd-kit/sortable');
+var dialog = require('@base-ui/react/dialog');
+var core = require('@dnd-kit/core');
+var utilities = require('@dnd-kit/utilities');
 var menu = require('@base-ui/react/menu');
 var reactVirtual = require('@tanstack/react-virtual');
 var reactDom = require('react-dom');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React7__default = /*#__PURE__*/_interopDefault(React7);
-var classNames2__default = /*#__PURE__*/_interopDefault(classNames2);
+var classnames7__default = /*#__PURE__*/_interopDefault(classnames7);
+var React21__default = /*#__PURE__*/_interopDefault(React21);
+
+// src/filter-list/base/FilterList.tsx
+
+// src/filter-list/utils/assertUnreachable.ts
+function assertUnreachable(value) {
+  throw new Error(`Unhandled value: ${String(value)}`);
+}
+
+// src/filter-list/utils/getFilterKey.ts
+function getFilterKey(definition) {
+  switch (definition.type) {
+    case "PROPERTY":
+      return definition.id ?? definition.key;
+    case "HAS_LINK":
+      return definition.id ?? `hasLink:${definition.linkName}`;
+    case "LINKED_PROPERTY":
+      return definition.id ?? `linkedProperty:${definition.linkName}:${definition.linkedPropertyKey}`;
+    case "KEYWORD_SEARCH":
+      return definition.id ?? `keywordSearch-${Array.isArray(definition.properties) ? definition.properties.join("-") : "all"}`;
+    case "CUSTOM":
+      return definition.id ?? definition.key;
+    default:
+      return assertUnreachable(definition);
+  }
+}
+
+// src/filter-list/utils/filterStateToWhereClause.ts
+function filterStateToPropertyFilter(state) {
+  switch (state.type) {
+    case "CONTAINS_TEXT": {
+      if (!state.value) {
+        return void 0;
+      }
+      const filter = {
+        $containsAnyTerm: state.value
+      };
+      if (state.isExcluding) {
+        return {
+          $not: filter
+        };
+      }
+      return filter;
+    }
+    case "TOGGLE": {
+      return state.enabled;
+    }
+    case "DATE_RANGE": {
+      const conditions = [];
+      if (state.minValue !== void 0) {
+        conditions.push({
+          $gte: state.minValue.toISOString()
+        });
+      }
+      if (state.maxValue !== void 0) {
+        conditions.push({
+          $lte: state.maxValue.toISOString()
+        });
+      }
+      if (conditions.length === 0 && !state.includeNull) {
+        return void 0;
+      }
+      let rangeFilter;
+      if (conditions.length === 1) {
+        rangeFilter = conditions[0];
+      } else if (conditions.length > 1) {
+        rangeFilter = {
+          $and: conditions
+        };
+      }
+      if (state.includeNull) {
+        if (rangeFilter) {
+          return {
+            $or: [rangeFilter, {
+              $isNull: true
+            }]
+          };
+        }
+        return {
+          $isNull: true
+        };
+      }
+      return rangeFilter;
+    }
+    case "NUMBER_RANGE": {
+      const conditions = [];
+      if (state.minValue !== void 0) {
+        conditions.push({
+          $gte: state.minValue
+        });
+      }
+      if (state.maxValue !== void 0) {
+        conditions.push({
+          $lte: state.maxValue
+        });
+      }
+      if (conditions.length === 0 && !state.includeNull) {
+        return void 0;
+      }
+      let rangeFilter;
+      if (conditions.length === 1) {
+        rangeFilter = conditions[0];
+      } else if (conditions.length > 1) {
+        rangeFilter = {
+          $and: conditions
+        };
+      }
+      if (state.includeNull) {
+        if (rangeFilter) {
+          return {
+            $or: [rangeFilter, {
+              $isNull: true
+            }]
+          };
+        }
+        return {
+          $isNull: true
+        };
+      }
+      return rangeFilter;
+    }
+    case "EXACT_MATCH": {
+      if (state.values.length === 0) {
+        return void 0;
+      }
+      const filter = state.values.length === 1 ? state.values[0] : {
+        $in: state.values
+      };
+      if (state.isExcluding) {
+        return {
+          $not: filter
+        };
+      }
+      return filter;
+    }
+    case "SELECT": {
+      if (state.selectedValues.length === 0) {
+        return void 0;
+      }
+      const isDateValue = state.selectedValues[0] instanceof Date;
+      const values = isDateValue ? state.selectedValues.map((v) => v.toISOString()) : state.selectedValues;
+      const filter = values.length === 1 ? values[0] : {
+        $in: values
+      };
+      if (state.isExcluding) {
+        return {
+          $not: filter
+        };
+      }
+      return filter;
+    }
+    case "TIMELINE": {
+      const conditions = [];
+      if (state.startDate !== void 0) {
+        conditions.push({
+          $gte: state.startDate.toISOString()
+        });
+      }
+      if (state.endDate !== void 0) {
+        conditions.push({
+          $lte: state.endDate.toISOString()
+        });
+      }
+      if (conditions.length === 0) {
+        return void 0;
+      }
+      if (conditions.length === 1) {
+        return conditions[0];
+      }
+      return {
+        $and: conditions
+      };
+    }
+    // These filter types are handled separately in buildWhereClause
+    // since they need access to the full definition, not just state
+    case "hasLink":
+    case "linkedProperty":
+    case "keywordSearch":
+    case "custom":
+      return void 0;
+    default:
+      return assertUnreachable(state);
+  }
+}
+function buildWhereClause(definitions, filterStates, operator, objectType) {
+  if (!definitions || definitions.length === 0) {
+    return {};
+  }
+  const clauses = [];
+  for (const definition of definitions) {
+    const state = filterStates.get(getFilterKey(definition));
+    if (!state) {
+      continue;
+    }
+    switch (definition.type) {
+      case "PROPERTY": {
+        const filter = filterStateToPropertyFilter(state);
+        if (filter !== void 0) {
+          clauses.push({
+            [definition.key]: filter
+          });
+        }
+        break;
+      }
+      case "HAS_LINK": {
+        if (state.type !== "hasLink") {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(`[FilterList] State type mismatch for hasLink filter "${definition.linkName}": expected hasLink, got ${state.type}`);
+          }
+          break;
+        }
+        if (!state.hasLink) {
+          break;
+        }
+        clauses.push({
+          [definition.linkName]: {
+            $isNotNull: true
+          }
+        });
+        break;
+      }
+      case "LINKED_PROPERTY": {
+        break;
+      }
+      case "KEYWORD_SEARCH": {
+        if (state.type !== "keywordSearch") {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(`[FilterList] State type mismatch for keywordSearch filter: expected keywordSearch, got ${state.type}`);
+          }
+          break;
+        }
+        if (!state.searchTerm) {
+          break;
+        }
+        const searchTerm = state.searchTerm.trim();
+        if (!searchTerm) {
+          break;
+        }
+        const properties = definition.properties;
+        let propertiesToSearch;
+        if (properties === "all") {
+          if (objectType?.__DefinitionMetadata?.properties) {
+            propertiesToSearch = Object.entries(objectType.__DefinitionMetadata.properties).filter(([, prop]) => prop.type === "string" && !prop.multiplicity).map(([key]) => key);
+          } else {
+            if (process.env.NODE_ENV !== "production") {
+              console.warn("[FilterList] Keyword search with properties: 'all' requires objectType to be provided. Filter will be skipped.");
+            }
+            break;
+          }
+        } else {
+          propertiesToSearch = properties;
+        }
+        if (propertiesToSearch.length === 0) {
+          break;
+        }
+        const containsOp = state.operator === "AND" ? "$containsAllTerms" : "$containsAnyTerm";
+        const propertySearches = propertiesToSearch.map((prop) => ({
+          [prop]: state.isExcluding ? {
+            $not: {
+              [containsOp]: searchTerm
+            }
+          } : {
+            [containsOp]: searchTerm
+          }
+        }));
+        if (propertySearches.length === 1) {
+          clauses.push(propertySearches[0]);
+        } else {
+          clauses.push({
+            $or: propertySearches
+          });
+        }
+        break;
+      }
+      case "CUSTOM": {
+        if (state.type !== "custom") {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(`[FilterList] State type mismatch for custom filter "${definition.key}": expected custom, got ${state.type}`);
+          }
+          break;
+        }
+        const customClause = definition.toWhereClause(state);
+        if (customClause && Object.keys(customClause).length > 0) {
+          clauses.push(customClause);
+        }
+        break;
+      }
+      default:
+        assertUnreachable(definition);
+    }
+  }
+  if (clauses.length === 0) {
+    return {};
+  }
+  if (clauses.length === 1) {
+    return clauses[0];
+  }
+  if (operator === "and") {
+    return {
+      $and: clauses
+    };
+  }
+  return {
+    $or: clauses
+  };
+}
+
+// src/filter-list/utils/filterValues.ts
+function filterHasActiveState(state) {
+  if (!state) return false;
+  switch (state.type) {
+    case "SELECT":
+      return state.selectedValues.length > 0;
+    case "EXACT_MATCH":
+      return state.values.length > 0;
+    case "CONTAINS_TEXT":
+      return state.value !== void 0 && state.value !== "";
+    case "NUMBER_RANGE":
+      return state.minValue !== void 0 || state.maxValue !== void 0 || state.includeNull === true;
+    case "DATE_RANGE":
+      return state.minValue !== void 0 || state.maxValue !== void 0 || state.includeNull === true;
+    case "TOGGLE":
+      return state.enabled;
+    case "hasLink":
+      return state.hasLink;
+    case "linkedProperty":
+      return filterHasActiveState(state.linkedFilterState);
+    case "keywordSearch":
+      return state.searchTerm !== void 0 && state.searchTerm !== "";
+    case "TIMELINE":
+      return state.startDate !== void 0 || state.endDate !== void 0;
+    case "custom":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/filter-list/hooks/useFilterListState.ts
+function buildInitialStates(definitions) {
+  const states = /* @__PURE__ */ new Map();
+  if (!definitions) {
+    return states;
+  }
+  for (const definition of definitions) {
+    const key = getFilterKey(definition);
+    switch (definition.type) {
+      case "PROPERTY": {
+        const state = definition.filterState;
+        if (state) {
+          states.set(key, state);
+        }
+        break;
+      }
+      case "HAS_LINK":
+      case "KEYWORD_SEARCH":
+      case "CUSTOM": {
+        const state = definition.defaultFilterState;
+        if (state) {
+          states.set(key, state);
+        }
+        break;
+      }
+      case "LINKED_PROPERTY": {
+        const innerState = definition.defaultLinkedFilterState;
+        if (innerState) {
+          const state = {
+            type: "linkedProperty",
+            linkedFilterState: innerState
+          };
+          states.set(key, state);
+        }
+        break;
+      }
+      default:
+        assertUnreachable(definition);
+    }
+  }
+  return states;
+}
+function useFilterListState(props) {
+  const {
+    objectSet,
+    filterDefinitions,
+    filterOperator = "and",
+    onFilterStateChanged,
+    onFilterClauseChanged
+  } = props;
+  const objectType = objectSet.$objectSetInternals.def;
+  const [filterStates, setFilterStates] = React21.useState(() => buildInitialStates(filterDefinitions));
+  const setFilterState = React21.useCallback((filterKey, state) => {
+    let newWhereClause;
+    setFilterStates((prev) => {
+      const next = new Map(prev);
+      next.set(filterKey, state);
+      newWhereClause = buildWhereClause(filterDefinitions, next, filterOperator, objectType);
+      return next;
+    });
+    if (newWhereClause !== void 0) {
+      onFilterClauseChanged?.(newWhereClause);
+    }
+    const definition = filterDefinitions?.find((d) => getFilterKey(d) === filterKey);
+    if (definition) {
+      onFilterStateChanged?.(definition, state);
+    }
+  }, [filterDefinitions, filterOperator, objectType, onFilterClauseChanged, onFilterStateChanged]);
+  const whereClause = React21.useMemo(() => buildWhereClause(filterDefinitions, filterStates, filterOperator, objectType), [filterDefinitions, filterStates, filterOperator, objectType]);
+  const activeFilterCount = React21.useMemo(() => {
+    let count = 0;
+    for (const state of filterStates.values()) {
+      if (filterHasActiveState(state)) {
+        count++;
+      }
+    }
+    return count;
+  }, [filterStates]);
+  const reset = React21.useCallback(() => {
+    const initialStates = buildInitialStates(filterDefinitions);
+    setFilterStates(initialStates);
+    const newWhereClause = buildWhereClause(filterDefinitions, initialStates, filterOperator, objectType);
+    onFilterClauseChanged?.(newWhereClause);
+  }, [filterDefinitions, filterOperator, objectType, onFilterClauseChanged]);
+  return React21.useMemo(() => ({
+    filterStates,
+    setFilterState,
+    whereClause,
+    activeFilterCount,
+    reset
+  }), [filterStates, setFilterState, whereClause, activeFilterCount, reset]);
+}
+
+// src/filter-list/base/FilterList.module.css
+var FilterList_default = {};
+
+// src/filter-list/base/FilterListContent.module.css
+var FilterListContent_default = {};
+
+// src/shared/ErrorBoundary.module.css
+var ErrorBoundary_default = {};
+
+// src/shared/ErrorBoundary.tsx
+var ErrorBoundary = class extends React21.Component {
+  state = {
+    hasError: false,
+    error: null
+  };
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true,
+      error
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("[ErrorBoundary]", error);
+    console.error("[ErrorBoundary] Component stack:", errorInfo.componentStack);
+    this.props.onError?.(error);
+  }
+  handleRetry = () => {
+    this.setState({
+      hasError: false,
+      error: null
+    });
+  };
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      return /* @__PURE__ */ React21__default.default.createElement("div", {
+        className: ErrorBoundary_default.errorContainer
+      }, /* @__PURE__ */ React21__default.default.createElement("p", {
+        className: ErrorBoundary_default.errorMessage
+      }, this.props.errorMessage ?? "Something went wrong"), /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+        className: ErrorBoundary_default.retryButton,
+        onClick: this.handleRetry,
+        "aria-label": "Retry"
+      }, "Retry"));
+    }
+    return this.props.children;
+  }
+};
+
+// src/filter-list/utils/coerceFilterValue.ts
+function coerceToString(value) {
+  if (value === void 0) return void 0;
+  return String(value);
+}
+function coerceToStringArray(values) {
+  if (values === void 0) return [];
+  return values.map((v) => String(v));
+}
+
+// src/base-components/checkbox/Checkbox.module.css
+var Checkbox_default = {};
+
+// src/base-components/checkbox/Checkbox.tsx
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function Checkbox({
+  indeterminate,
+  className,
+  indicatorProps,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(checkbox.Checkbox.Root, _extends({
+    className: classnames7__default.default(Checkbox_default.osdkCheckboxRoot, className),
+    indeterminate
+  }, rest), /* @__PURE__ */ React21__default.default.createElement(checkbox.Checkbox.Indicator, _extends({}, indicatorProps, {
+    className: classnames7__default.default(Checkbox_default.osdkCheckboxIndicator, indicatorProps?.className)
+  }), indeterminate ? /* @__PURE__ */ React21__default.default.createElement(icons.Minus, {
+    color: "currentColor"
+  }) : /* @__PURE__ */ React21__default.default.createElement(icons.Tick, {
+    color: "currentColor"
+  })));
+}
+function usePropertyAggregation(objectType, propertyKey, options) {
+  const aggregateOptions = React21.useMemo(() => ({
+    $select: {
+      $count: "unordered"
+    },
+    $groupBy: {
+      [propertyKey]: {
+        $exact: {
+          $includeNullValue: true
+        }
+      }
+    }
+  }), [propertyKey]);
+  const {
+    data: countData,
+    isLoading,
+    error
+  } = experimental.useOsdkAggregation(objectType, {
+    aggregate: aggregateOptions,
+    where: options?.where
+  });
+  const result = React21.useMemo(() => {
+    if (!countData) {
+      return {
+        data: [],
+        maxCount: 0
+      };
+    }
+    const values = [];
+    let maxCount = 0;
+    const dataArray = countData;
+    for (const item of dataArray) {
+      const rawValue = item.$group[propertyKey];
+      const count = item.$count ?? 0;
+      if (rawValue == null) {
+        values.push({
+          value: "",
+          count,
+          isNull: true
+        });
+      } else {
+        values.push({
+          value: String(rawValue),
+          count
+        });
+      }
+      maxCount = Math.max(maxCount, count);
+    }
+    values.sort((a, b) => b.count - a.count);
+    if (options?.limit && values.length > options.limit) {
+      return {
+        data: values.slice(0, options.limit),
+        maxCount
+      };
+    }
+    return {
+      data: values,
+      maxCount
+    };
+  }, [countData, propertyKey, options?.limit]);
+  return {
+    data: result.data,
+    maxCount: result.maxCount,
+    isLoading,
+    error: error ?? null
+  };
+}
+
+// src/filter-list/base/inputs/CheckboxListInput.module.css
+var CheckboxListInput_default = {};
+
+// src/filter-list/base/inputs/shared.module.css
+var shared_default = {};
+
+// src/filter-list/base/inputs/CheckboxListInput.tsx
+function CheckboxListInputInner({
+  objectType,
+  propertyKey,
+  selectedValues,
+  onChange,
+  whereClause,
+  className,
+  style
+}) {
+  const {
+    data,
+    isLoading,
+    error
+  } = usePropertyAggregation(objectType, propertyKey, {
+    where: whereClause
+  });
+  const values = React21.useMemo(() => data.map((item) => item.value), [data]);
+  const selectedSet = React21.useMemo(() => new Set(selectedValues), [selectedValues]);
+  const toggleValue = React21.useCallback((value) => {
+    if (selectedSet.has(value)) {
+      onChange(selectedValues.filter((v) => v !== value));
+    } else {
+      onChange([...selectedValues, value]);
+    }
+  }, [selectedValues, selectedSet, onChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(CheckboxListInput_default.checkboxList, className),
+    style,
+    "data-loading": isLoading
+  }, error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Error loading values: ", error.message), !error && values.length === 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.emptyMessage
+  }, isLoading ? "Loading values..." : "No values available"), (values.length > 0 || isLoading) && /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, isLoading && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Updating..."), values.map((value) => {
+    const isSelected = selectedSet.has(value);
+    return /* @__PURE__ */ React21__default.default.createElement("div", {
+      key: value,
+      className: CheckboxListInput_default.checkboxRow,
+      "data-selected": isSelected
+    }, /* @__PURE__ */ React21__default.default.createElement("label", {
+      className: CheckboxListInput_default.checkboxLabel
+    }, /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
+      checked: isSelected,
+      onCheckedChange: () => toggleValue(value)
+    }), /* @__PURE__ */ React21__default.default.createElement("span", {
+      className: CheckboxListInput_default.valueText
+    }, value)));
+  })));
+}
+var CheckboxListInput = /* @__PURE__ */ React21.memo(CheckboxListInputInner);
+
+// src/filter-list/base/inputs/ContainsTextInput.module.css
+var ContainsTextInput_default = {};
+
+// src/filter-list/base/inputs/ContainsTextInput.tsx
+function ContainsTextInputInner({
+  value,
+  onChange,
+  placeholder = "Search...",
+  debounceMs = 300,
+  className,
+  style,
+  renderSearchIcon,
+  renderClearIcon
+}) {
+  const [localValue, setLocalValue] = React21.useState(value ?? "");
+  const onChangeRef = React21.useRef(onChange);
+  onChangeRef.current = onChange;
+  const debouncedOnChange = React21.useMemo(() => lodashEs.debounce((newValue) => {
+    onChangeRef.current(newValue.length > 0 ? newValue : void 0);
+  }, debounceMs), [debounceMs]);
+  React21.useEffect(() => {
+    return () => {
+      debouncedOnChange.cancel();
+    };
+  }, [debouncedOnChange]);
+  React21.useEffect(() => {
+    setLocalValue(value ?? "");
+    debouncedOnChange.cancel();
+  }, [value, debouncedOnChange]);
+  const handleInputChange = React21.useCallback((e) => {
+    setLocalValue(e.target.value);
+    debouncedOnChange(e.target.value);
+  }, [debouncedOnChange]);
+  const handleClear = React21.useCallback(() => {
+    setLocalValue("");
+    debouncedOnChange.cancel();
+    onChangeRef.current(void 0);
+  }, [debouncedOnChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(ContainsTextInput_default.textInput, className),
+    style,
+    "data-has-value": !!localValue
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ContainsTextInput_default.inputGroup
+  }, renderSearchIcon ? renderSearchIcon() : /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: ContainsTextInput_default.searchIcon
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Search, {
+    color: "currentColor"
+  })), /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "text",
+    className: ContainsTextInput_default.input,
+    value: localValue,
+    onChange: handleInputChange,
+    placeholder,
+    "aria-label": placeholder
+  }), localValue && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: ContainsTextInput_default.clearButton,
+    onClick: handleClear,
+    "aria-label": "Clear search"
+  }, renderClearIcon ? renderClearIcon() : /* @__PURE__ */ React21__default.default.createElement(icons.Cross, {
+    color: "currentColor"
+  }))));
+}
+var ContainsTextInput = /* @__PURE__ */ React21.memo(ContainsTextInputInner);
+
+// src/filter-list/base/inputs/dateUtils.ts
+function formatDateForInput(date) {
+  if (!date) return "";
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseDateFromInput(value) {
+  if (!value) return void 0;
+  const date = /* @__PURE__ */ new Date(value + "T00:00:00");
+  return isNaN(date.getTime()) ? void 0 : date;
+}
+function formatDateForDisplay(date, fallback = "") {
+  if (!date) return fallback;
+  return date.toLocaleDateString(void 0, {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+
+// src/filter-list/utils/aggregationHelpers.ts
+function createGroupByAggregateOptions(propertyKey) {
+  return {
+    $select: {
+      $count: "unordered"
+    },
+    $groupBy: {
+      [propertyKey]: "exact"
+    }
+  };
+}
+function createNullCountAggregateOptions() {
+  return {
+    $select: {
+      $count: "unordered"
+    }
+  };
+}
+function createNullWhereClause(propertyKey) {
+  return {
+    [propertyKey]: {
+      $isNull: true
+    }
+  };
+}
+
+// src/filter-list/base/inputs/createHistogramBuckets.ts
+var HISTOGRAM_BUCKETS = 20;
+function createHistogramBuckets(pairs, range, toNumber, fromNumber) {
+  if (pairs.length === 0) return [];
+  const minNum = toNumber(range.min);
+  const maxNum = toNumber(range.max);
+  const rangeSize = maxNum - minNum;
+  if (rangeSize === 0) {
+    const totalCount = pairs.reduce((sum, p) => sum + p.count, 0);
+    return [{
+      min: range.min,
+      max: range.max,
+      count: totalCount
+    }];
+  }
+  const bucketSize = rangeSize / HISTOGRAM_BUCKETS;
+  const bucketCounts = new Array(HISTOGRAM_BUCKETS).fill(0);
+  for (const {
+    value,
+    count
+  } of pairs) {
+    const bucketIndex = Math.min(Math.floor((toNumber(value) - minNum) / bucketSize), HISTOGRAM_BUCKETS - 1);
+    bucketCounts[bucketIndex] += count;
+  }
+  return bucketCounts.map((count, i) => ({
+    min: fromNumber(minNum + i * bucketSize),
+    max: fromNumber(minNum + (i + 1) * bucketSize),
+    count
+  }));
+}
+function getMaxBucketCount(buckets) {
+  return Math.max(...buckets.map((b) => b.count), 1);
+}
+
+// src/filter-list/base/inputs/RangeInput.module.css
+var RangeInput_default = {};
+
+// src/filter-list/base/inputs/RangeInput.tsx
+function _extends2() {
+  return _extends2 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends2.apply(null, arguments);
+}
+var DEBOUNCE_MS = 300;
+function RangeInputInner({
+  objectType,
+  propertyKey,
+  minValue,
+  maxValue,
+  onChange,
+  objectSet,
+  showHistogram = true,
+  className,
+  style,
+  config
+}) {
+  const minInputId = React21.useId();
+  const maxInputId = React21.useId();
+  const [localMin, setLocalMin] = React21.useState(config.formatValue(minValue));
+  const [localMax, setLocalMax] = React21.useState(config.formatValue(maxValue));
+  const onChangeRef = React21.useRef(onChange);
+  onChangeRef.current = onChange;
+  const minValueRef = React21.useRef(minValue);
+  minValueRef.current = minValue;
+  const maxValueRef = React21.useRef(maxValue);
+  maxValueRef.current = maxValue;
+  const debouncedMinChange = React21.useMemo(() => lodashEs.debounce((newValue) => {
+    const parsed = config.parseValue(newValue);
+    onChangeRef.current(parsed, maxValueRef.current);
+  }, DEBOUNCE_MS), [config]);
+  const debouncedMaxChange = React21.useMemo(() => lodashEs.debounce((newValue) => {
+    const parsed = config.parseValue(newValue);
+    onChangeRef.current(minValueRef.current, parsed);
+  }, DEBOUNCE_MS), [config]);
+  React21.useEffect(() => {
+    setLocalMin(config.formatValue(minValue));
+    debouncedMinChange.cancel();
+  }, [minValue, config, debouncedMinChange]);
+  React21.useEffect(() => {
+    setLocalMax(config.formatValue(maxValue));
+    debouncedMaxChange.cancel();
+  }, [maxValue, config, debouncedMaxChange]);
+  React21.useEffect(() => {
+    return () => {
+      debouncedMinChange.cancel();
+      debouncedMaxChange.cancel();
+    };
+  }, [debouncedMinChange, debouncedMaxChange]);
+  const aggregateOptions = React21.useMemo(() => createGroupByAggregateOptions(propertyKey), [propertyKey]);
+  const {
+    data: aggregateData,
+    isLoading
+  } = experimental.useOsdkAggregation(objectType, {
+    aggregate: aggregateOptions
+  });
+  const valueCountPairs = React21.useMemo(() => {
+    if (!aggregateData) return [];
+    const dataArray = aggregateData;
+    const pairs = [];
+    for (const item of dataArray) {
+      const rawValue = item.$group[propertyKey];
+      if (rawValue != null) {
+        const parsed = config.parseValue(String(rawValue));
+        if (parsed !== void 0) {
+          pairs.push({
+            value: parsed,
+            count: item.$count ?? 0
+          });
+        }
+      }
+    }
+    return pairs;
+  }, [aggregateData, propertyKey, config]);
+  const computedRange = React21.useMemo(() => {
+    if (valueCountPairs.length === 0) return {
+      min: void 0,
+      max: void 0
+    };
+    const min = valueCountPairs.reduce((acc, p) => Math.min(acc, config.toNumber(p.value)), Infinity);
+    const max = valueCountPairs.reduce((acc, p) => Math.max(acc, config.toNumber(p.value)), -Infinity);
+    return {
+      min: config.fromNumber(min),
+      max: config.fromNumber(max)
+    };
+  }, [valueCountPairs, config]);
+  const dataRange = React21.useMemo(() => ({
+    dataMin: computedRange.min,
+    dataMax: computedRange.max
+  }), [computedRange.min, computedRange.max]);
+  const buckets = React21.useMemo(() => {
+    if (!showHistogram || valueCountPairs.length === 0 || computedRange.min === void 0 || computedRange.max === void 0) {
+      return [];
+    }
+    return createHistogramBuckets(valueCountPairs, {
+      min: computedRange.min,
+      max: computedRange.max
+    }, config.toNumber, config.fromNumber);
+  }, [showHistogram, valueCountPairs, computedRange, config]);
+  const maxBucketCount = React21.useMemo(() => getMaxBucketCount(buckets), [buckets]);
+  const handleMinChange = React21.useCallback((e) => {
+    const newValue = e.target.value;
+    setLocalMin(newValue);
+    debouncedMinChange(newValue);
+  }, [debouncedMinChange]);
+  const handleMaxChange = React21.useCallback((e) => {
+    const newValue = e.target.value;
+    setLocalMax(newValue);
+    debouncedMaxChange(newValue);
+  }, [debouncedMaxChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(RangeInput_default.rangeInput, className),
+    style,
+    "data-loading": isLoading
+  }, showHistogram && buckets.length > 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: RangeInput_default.histogramContainer
+  }, buckets.map((bucket, index) => {
+    const height = bucket.count / maxBucketCount * 100;
+    const isInRange = (minValue === void 0 || config.toNumber(bucket.max) >= config.toNumber(minValue)) && (maxValue === void 0 || config.toNumber(bucket.min) <= config.toNumber(maxValue));
+    return /* @__PURE__ */ React21__default.default.createElement("div", {
+      key: index,
+      className: RangeInput_default.histogramBar,
+      "data-in-range": isInRange,
+      style: {
+        height: `${Math.max(height, 2)}%`
+      },
+      title: config.formatTooltip(bucket.min, bucket.max, bucket.count)
+    });
+  })), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: RangeInput_default.rangeInputs
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: RangeInput_default.inputWrapper
+  }, /* @__PURE__ */ React21__default.default.createElement("label", {
+    htmlFor: minInputId,
+    className: RangeInput_default.inputLabel
+  }, config.minLabel), /* @__PURE__ */ React21__default.default.createElement(input.Input, _extends2({
+    id: minInputId,
+    type: config.inputType,
+    className: RangeInput_default.input,
+    value: localMin,
+    onChange: handleMinChange,
+    placeholder: dataRange.dataMin !== void 0 && config.formatPlaceholder ? config.formatPlaceholder(dataRange.dataMin) : void 0
+  }, config.inputProps))), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: RangeInput_default.separator,
+    "aria-hidden": "true"
+  }, "\u2013"), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: RangeInput_default.inputWrapper
+  }, /* @__PURE__ */ React21__default.default.createElement("label", {
+    htmlFor: maxInputId,
+    className: RangeInput_default.inputLabel
+  }, config.maxLabel), /* @__PURE__ */ React21__default.default.createElement(input.Input, _extends2({
+    id: maxInputId,
+    type: config.inputType,
+    className: RangeInput_default.input,
+    value: localMax,
+    onChange: handleMaxChange,
+    placeholder: dataRange.dataMax !== void 0 && config.formatPlaceholder ? config.formatPlaceholder(dataRange.dataMax) : void 0
+  }, config.inputProps)))), isLoading && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Loading..."));
+}
+var RangeInput = /* @__PURE__ */ React21.memo(RangeInputInner);
+
+// src/filter-list/base/inputs/DateRangeInput.tsx
+function _extends3() {
+  return _extends3 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends3.apply(null, arguments);
+}
+var dateConfig = {
+  inputType: "date",
+  formatValue: formatDateForInput,
+  parseValue: parseDateFromInput,
+  toNumber: (d) => d.getTime(),
+  fromNumber: (t) => new Date(t),
+  minLabel: "From",
+  maxLabel: "To",
+  formatTooltip: (min, max, count) => `${formatDateForInput(min)} - ${formatDateForInput(max)}: ${count.toLocaleString()}`
+};
+function DateRangeInputInner(props) {
+  return /* @__PURE__ */ React21__default.default.createElement(RangeInput, _extends3({}, props, {
+    config: dateConfig
+  }));
+}
+var DateRangeInput = /* @__PURE__ */ React21.memo(DateRangeInputInner);
+
+// src/filter-list/base/inputs/LinkedPropertyInput.module.css
+var LinkedPropertyInput_default = {};
+
+// src/filter-list/base/inputs/ListogramInput.module.css
+var ListogramInput_default = {};
+
+// src/filter-list/base/inputs/ListogramInput.tsx
+function ListogramInputInner({
+  objectType,
+  propertyKey,
+  selectedValues,
+  onChange,
+  whereClause,
+  className,
+  style,
+  maxVisibleItems
+}) {
+  const [isExpanded, setIsExpanded] = React21.useState(false);
+  const {
+    data: values,
+    maxCount,
+    isLoading,
+    error
+  } = usePropertyAggregation(objectType, propertyKey, {
+    where: whereClause
+  });
+  const selectedSet = React21.useMemo(() => new Set(selectedValues), [selectedValues]);
+  const toggleValue = React21.useCallback((value) => {
+    if (selectedSet.has(value)) {
+      onChange(selectedValues.filter((v) => v !== value));
+    } else {
+      onChange([...selectedValues, value]);
+    }
+  }, [selectedValues, selectedSet, onChange]);
+  const displayValues = React21.useMemo(() => {
+    if (isExpanded || !maxVisibleItems) return values;
+    return values.slice(0, maxVisibleItems);
+  }, [values, maxVisibleItems, isExpanded]);
+  const hasMore = maxVisibleItems != null && values.length > maxVisibleItems;
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(ListogramInput_default.listogram, className),
+    style,
+    "data-loading": isLoading
+  }, isLoading && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Loading values..."), error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Error loading values: ", error.message), !isLoading && !error && values.length === 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.emptyMessage
+  }, "No values available"), (values.length > 0 || isLoading) && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ListogramInput_default.container
+  }, displayValues.map(({
+    value,
+    count
+  }) => {
+    const isSelected = selectedSet.has(value);
+    const percentage = maxCount > 0 ? count / maxCount * 100 : 0;
+    return /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+      key: value,
+      type: "button",
+      className: ListogramInput_default.row,
+      onClick: () => toggleValue(value),
+      "aria-pressed": isSelected
+    }, /* @__PURE__ */ React21__default.default.createElement("span", {
+      className: ListogramInput_default.label
+    }, value), /* @__PURE__ */ React21__default.default.createElement("span", {
+      className: ListogramInput_default.bar
+    }, /* @__PURE__ */ React21__default.default.createElement("span", {
+      className: ListogramInput_default.barFill,
+      style: {
+        width: `${percentage}%`
+      }
+    })), /* @__PURE__ */ React21__default.default.createElement("span", {
+      className: ListogramInput_default.count
+    }, count.toLocaleString()));
+  }), hasMore && !isExpanded && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: ListogramInput_default.row,
+    onClick: () => setIsExpanded(true)
+  }, "View all (", values.length, ")")));
+}
+var ListogramInput = /* @__PURE__ */ React21.memo(ListogramInputInner);
+
+// src/filter-list/base/inputs/MultiDateInput.module.css
+var MultiDateInput_default = {};
+
+// src/filter-list/base/inputs/MultiDateInput.tsx
+function MultiDateInputInner({
+  selectedDates,
+  onChange,
+  className,
+  style,
+  minDate,
+  maxDate,
+  showClearAll = true
+}) {
+  const addDate = React21.useCallback((date) => {
+    const dateStr = formatDateForInput(date);
+    const exists = selectedDates.some((d) => formatDateForInput(d) === dateStr);
+    if (!exists) {
+      onChange([...selectedDates, date].sort((a, b) => a.getTime() - b.getTime()));
+    }
+  }, [selectedDates, onChange]);
+  const removeDate = React21.useCallback((date) => {
+    const dateStr = formatDateForInput(date);
+    onChange(selectedDates.filter((d) => formatDateForInput(d) !== dateStr));
+  }, [selectedDates, onChange]);
+  const clearAll = React21.useCallback(() => {
+    onChange([]);
+  }, [onChange]);
+  const handleDateChange = React21.useCallback((e) => {
+    const date = parseDateFromInput(e.target.value);
+    if (date) {
+      addDate(date);
+      e.target.value = "";
+    }
+  }, [addDate]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(MultiDateInput_default.multiDate, className),
+    style
+  }, selectedDates.length > 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.tagContainer
+  }, selectedDates.map((date) => /* @__PURE__ */ React21__default.default.createElement("span", {
+    key: date.toISOString(),
+    className: shared_default.tag
+  }, formatDateForDisplay(date), /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: shared_default.tagRemove,
+    onClick: () => removeDate(date),
+    "aria-label": `Remove ${formatDateForDisplay(date)}`
+  }, "\xD7"))), showClearAll && selectedDates.length > 1 && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: MultiDateInput_default.clearAll,
+    onClick: clearAll,
+    "aria-label": "Clear all dates"
+  }, "Clear all")), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: MultiDateInput_default.calendarContainer
+  }, /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "date",
+    className: MultiDateInput_default.input,
+    onChange: handleDateChange,
+    min: minDate ? formatDateForInput(minDate) : void 0,
+    max: maxDate ? formatDateForInput(maxDate) : void 0,
+    "aria-label": "Add date"
+  })));
+}
+var MultiDateInput = /* @__PURE__ */ React21.memo(MultiDateInputInner);
+
+// src/base-components/combobox/Combobox.module.css
+var Combobox_default = {};
+
+// src/base-components/combobox/Combobox.tsx
+function _extends4() {
+  return _extends4 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends4.apply(null, arguments);
+}
+function ComboboxInput({
+  className,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(Combobox_default.osdkComboboxInputWrapper, className)
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Search, {
+    className: Combobox_default.osdkComboboxSearchIcon,
+    color: "currentColor"
+  }), /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Input, _extends4({
+    className: Combobox_default.osdkComboboxInput
+  }, rest)));
+}
+function ComboboxPositioner({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Positioner, _extends4({
+    className: classnames7__default.default(Combobox_default.osdkComboboxPositioner, className),
+    sideOffset: 4
+  }, rest), children);
+}
+function ComboboxPopup({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Popup, _extends4({
+    className: classnames7__default.default(Combobox_default.osdkComboboxPopup, className)
+  }, rest), children);
+}
+function ComboboxItem({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Item, _extends4({
+    className: classnames7__default.default(Combobox_default.osdkComboboxItem, className)
+  }, rest), children);
+}
+function ComboboxClear({
+  className,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Clear, _extends4({
+    className: classnames7__default.default(Combobox_default.osdkComboboxClear, className),
+    "aria-label": "Clear all"
+  }, rest), /* @__PURE__ */ React21__default.default.createElement(icons.Cross, {
+    color: "currentColor"
+  }));
+}
+function ComboboxEmpty({
+  children,
+  className
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(combobox.Combobox.Empty, {
+    className: classnames7__default.default(Combobox_default.osdkComboboxEmpty, className)
+  }, children);
+}
+var Combobox = {
+  Root: combobox.Combobox.Root,
+  Input: ComboboxInput,
+  Portal: combobox.Combobox.Portal,
+  Positioner: ComboboxPositioner,
+  Popup: ComboboxPopup,
+  Item: ComboboxItem,
+  Clear: ComboboxClear,
+  Empty: ComboboxEmpty
+};
+
+// src/filter-list/base/inputs/MultiSelectInput.module.css
+var MultiSelectInput_default = {};
+
+// src/filter-list/base/inputs/MultiSelectInput.tsx
+function MultiSelectInputInner({
+  objectType,
+  propertyKey,
+  selectedValues,
+  onChange,
+  whereClause,
+  className,
+  style,
+  placeholder = "Select values...",
+  maxDisplayedTags = 3,
+  showClearAll = true
+}) {
+  const {
+    data: values,
+    isLoading,
+    error
+  } = usePropertyAggregation(objectType, propertyKey, {
+    where: whereClause
+  });
+  const handleValueChange = React21.useCallback((newValues) => {
+    onChange(newValues ?? []);
+  }, [onChange]);
+  const removeValue = React21.useCallback((value) => {
+    onChange(selectedValues.filter((v) => v !== value));
+  }, [selectedValues, onChange]);
+  const clearAll = React21.useCallback(() => {
+    onChange([]);
+  }, [onChange]);
+  const displayedTags = selectedValues.slice(0, maxDisplayedTags);
+  const remainingCount = selectedValues.length - maxDisplayedTags;
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(MultiSelectInput_default.multiSelect, className),
+    style,
+    "data-loading": isLoading
+  }, error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Error loading options: ", error.message), !error && values.length === 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.emptyMessage
+  }, isLoading ? "Loading options..." : "No options available"), (values.length > 0 || isLoading) && /* @__PURE__ */ React21__default.default.createElement(Combobox.Root, {
+    multiple: true,
+    value: selectedValues,
+    onValueChange: handleValueChange
+  }, isLoading && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Updating..."), selectedValues.length > 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.tagContainer
+  }, displayedTags.map((value) => /* @__PURE__ */ React21__default.default.createElement("span", {
+    key: value,
+    className: shared_default.tag
+  }, value, /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: shared_default.tagRemove,
+    onClick: () => removeValue(value),
+    "aria-label": `Remove ${value}`
+  }, "\xD7"))), remainingCount > 0 && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: shared_default.tag
+  }, "+", remainingCount, " more")), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: MultiSelectInput_default.inputRow
+  }, /* @__PURE__ */ React21__default.default.createElement(Combobox.Input, {
+    placeholder: selectedValues.length > 0 ? `${selectedValues.length} selected` : placeholder,
+    "aria-label": `Search ${propertyKey} values`
+  }), showClearAll && selectedValues.length > 0 && /* @__PURE__ */ React21__default.default.createElement(Combobox.Clear, {
+    className: MultiSelectInput_default.clearButton,
+    onClick: clearAll,
+    "aria-label": "Clear all selections"
+  })), /* @__PURE__ */ React21__default.default.createElement(Combobox.Portal, null, /* @__PURE__ */ React21__default.default.createElement(Combobox.Positioner, null, /* @__PURE__ */ React21__default.default.createElement(Combobox.Popup, null, values.length === 0 ? /* @__PURE__ */ React21__default.default.createElement(Combobox.Empty, null, "No options available") : values.map(({
+    value,
+    count
+  }) => /* @__PURE__ */ React21__default.default.createElement(Combobox.Item, {
+    key: value,
+    value
+  }, /* @__PURE__ */ React21__default.default.createElement("span", null, value), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: MultiSelectInput_default.count
+  }, "(", count.toLocaleString(), ")"))))))));
+}
+var MultiSelectInput = /* @__PURE__ */ React21.memo(MultiSelectInputInner);
+function _extends5() {
+  return _extends5 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends5.apply(null, arguments);
+}
+function formatNumber(value) {
+  return value !== void 0 ? String(value) : "";
+}
+function parseNumber(value) {
+  if (value === "") return void 0;
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? void 0 : parsed;
+}
+var numberConfig = {
+  inputType: "number",
+  formatValue: formatNumber,
+  parseValue: parseNumber,
+  toNumber: (v) => v,
+  fromNumber: (v) => v,
+  minLabel: "Min",
+  maxLabel: "Max",
+  formatTooltip: (min, max, count) => `${min.toFixed(1)} - ${max.toFixed(1)}: ${count.toLocaleString()}`,
+  formatPlaceholder: (value) => value.toFixed(0),
+  inputProps: {
+    step: "any"
+  }
+};
+function NumberRangeInputInner(props) {
+  return /* @__PURE__ */ React21__default.default.createElement(RangeInput, _extends5({}, props, {
+    config: numberConfig
+  }));
+}
+var NumberRangeInput = /* @__PURE__ */ React21.memo(NumberRangeInputInner);
+
+// src/filter-list/base/inputs/SingleDateInput.module.css
+var SingleDateInput_default = {};
+
+// src/filter-list/base/inputs/SingleDateInput.tsx
+function SingleDateInputInner({
+  selectedDate,
+  onChange,
+  className,
+  style,
+  minDate,
+  maxDate,
+  placeholder = "Select a date...",
+  showClearButton = true
+}) {
+  const handleChange = React21.useCallback((e) => {
+    const date = parseDateFromInput(e.target.value);
+    onChange(date);
+  }, [onChange]);
+  const handleClear = React21.useCallback(() => {
+    onChange(void 0);
+  }, [onChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(SingleDateInput_default.singleDate, className),
+    style
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: SingleDateInput_default.dateContainer
+  }, /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "date",
+    className: SingleDateInput_default.input,
+    value: formatDateForInput(selectedDate),
+    onChange: handleChange,
+    min: minDate ? formatDateForInput(minDate) : void 0,
+    max: maxDate ? formatDateForInput(maxDate) : void 0,
+    placeholder,
+    "aria-label": "Select date"
+  }), showClearButton && selectedDate !== void 0 && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: SingleDateInput_default.clearButton,
+    onClick: handleClear,
+    "aria-label": "Clear date"
+  }, "\xD7")));
+}
+var SingleDateInput = /* @__PURE__ */ React21.memo(SingleDateInputInner);
+
+// src/base-components/select/Select.module.css
+var Select_default = {};
+
+// src/base-components/select/Select.tsx
+function _extends6() {
+  return _extends6 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends6.apply(null, arguments);
+}
+function SelectRoot({
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(select.Select.Root, rest, children);
+}
+function SelectTrigger({
+  className,
+  placeholder,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(select.Select.Trigger, _extends6({
+    className: classnames7__default.default(Select_default.osdkSelectTrigger, className)
+  }, rest), children ?? /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(select.Select.Value, null, (value) => value != null ? String(value) : placeholder), /* @__PURE__ */ React21__default.default.createElement(select.Select.Icon, {
+    className: Select_default.osdkSelectIcon
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.CaretDown, {
+    color: "currentColor"
+  }))));
+}
+function SelectPositioner({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(select.Select.Positioner, _extends6({
+    className: classnames7__default.default(Select_default.osdkSelectPositioner, className),
+    sideOffset: 4
+  }, rest), children);
+}
+function SelectPopup({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(select.Select.Popup, _extends6({
+    className: classnames7__default.default(Select_default.osdkSelectPopup, className)
+  }, rest), children);
+}
+function SelectItem({
+  className,
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(select.Select.Item, _extends6({
+    className: classnames7__default.default(Select_default.osdkSelectItem, className)
+  }, rest), /* @__PURE__ */ React21__default.default.createElement(select.Select.ItemText, null, children));
+}
+var Select = {
+  Root: SelectRoot,
+  Trigger: SelectTrigger,
+  Portal: select.Select.Portal,
+  Positioner: SelectPositioner,
+  Popup: SelectPopup,
+  Item: SelectItem
+};
+
+// src/filter-list/base/inputs/SingleSelectInput.module.css
+var SingleSelectInput_default = {};
+
+// src/filter-list/base/inputs/SingleSelectInput.tsx
+function SingleSelectInputInner({
+  objectType,
+  propertyKey,
+  selectedValue,
+  onChange,
+  whereClause,
+  className,
+  style,
+  placeholder = "Select a value...",
+  showClearButton = true,
+  showCounts = false
+}) {
+  const {
+    data: values,
+    isLoading,
+    error
+  } = usePropertyAggregation(objectType, propertyKey, {
+    where: whereClause
+  });
+  const handleValueChange = React21.useCallback((value) => {
+    onChange(value ?? void 0);
+  }, [onChange]);
+  const handleClear = React21.useCallback(() => {
+    onChange(void 0);
+  }, [onChange]);
+  const items = React21.useMemo(() => {
+    const result = {};
+    for (const {
+      value,
+      count
+    } of values) {
+      result[value] = showCounts ? `${value} (${count.toLocaleString()})` : value;
+    }
+    return result;
+  }, [values, showCounts]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(SingleSelectInput_default.singleSelect, className),
+    style,
+    "data-loading": isLoading
+  }, isLoading && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Loading options..."), error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Error loading options: ", error.message), !isLoading && !error && values.length === 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.emptyMessage
+  }, "No options available"), (values.length > 0 || isLoading) && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: SingleSelectInput_default.selectContainer
+  }, /* @__PURE__ */ React21__default.default.createElement(Select.Root, {
+    value: selectedValue ?? null,
+    onValueChange: handleValueChange,
+    items
+  }, /* @__PURE__ */ React21__default.default.createElement(Select.Trigger, {
+    placeholder,
+    "aria-label": `Select ${propertyKey}`
+  }), /* @__PURE__ */ React21__default.default.createElement(Select.Portal, null, /* @__PURE__ */ React21__default.default.createElement(Select.Positioner, null, /* @__PURE__ */ React21__default.default.createElement(Select.Popup, null, values.map(({
+    value,
+    count
+  }) => /* @__PURE__ */ React21__default.default.createElement(Select.Item, {
+    key: value,
+    value
+  }, showCounts ? `${value} (${count.toLocaleString()})` : value)))))), showClearButton && selectedValue !== void 0 && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: SingleSelectInput_default.clearButton,
+    onClick: handleClear,
+    "aria-label": "Clear selection"
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Cross, {
+    color: "currentColor"
+  }))));
+}
+var SingleSelectInput = /* @__PURE__ */ React21.memo(SingleSelectInputInner);
+
+// src/filter-list/base/inputs/TextTagsInput.module.css
+var TextTagsInput_default = {};
+
+// src/filter-list/base/inputs/TextTagsInput.tsx
+var TAG_SEPARATOR_PATTERN = /[,\n]/;
+var TagItem = /* @__PURE__ */ React21.memo(function TagItem2({
+  tag,
+  onRemove
+}) {
+  const handleRemove = React21.useCallback(() => {
+    onRemove(tag);
+  }, [tag, onRemove]);
+  return /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: shared_default.tag
+  }, tag, /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: shared_default.tagRemove,
+    onClick: handleRemove,
+    "aria-label": `Remove ${tag}`
+  }, "\xD7"));
+});
+function TextTagsInputInner({
+  objectType,
+  propertyKey,
+  tags,
+  onChange,
+  whereClause,
+  className,
+  style,
+  placeholder = "Add a tag...",
+  allowCustomTags = true,
+  suggestionLimit = 10
+}) {
+  const [inputValue, setInputValue] = React21.useState("");
+  const {
+    data: suggestions,
+    isLoading,
+    error
+  } = usePropertyAggregation(objectType, propertyKey, {
+    limit: suggestionLimit ?? 0,
+    where: whereClause
+  });
+  const filteredSuggestions = React21.useMemo(() => {
+    if (!suggestionLimit) return [];
+    const lowerInput = inputValue.toLowerCase();
+    return suggestions.filter((s) => (!inputValue.trim() || s.value.toLowerCase().includes(lowerInput)) && !tags.includes(s.value)).slice(0, suggestionLimit);
+  }, [suggestions, inputValue, tags, suggestionLimit]);
+  const addTag = React21.useCallback((tag) => {
+    const trimmedTag = tag.trim();
+    if (trimmedTag && !tags.includes(trimmedTag)) {
+      onChange([...tags, trimmedTag]);
+    }
+    setInputValue("");
+  }, [tags, onChange]);
+  const removeTag = React21.useCallback((tag) => {
+    onChange(tags.filter((t) => t !== tag));
+  }, [tags, onChange]);
+  const handleValueChange = React21.useCallback((newTags) => {
+    onChange(newTags ?? []);
+  }, [onChange]);
+  const handleInputValueChange = React21.useCallback((value) => {
+    setInputValue(value);
+  }, []);
+  const handleKeyDown = React21.useCallback((e) => {
+    if (e.key === "Enter" && inputValue.trim()) {
+      if (filteredSuggestions.length > 0) {
+        return;
+      }
+      e.preventDefault();
+      if (allowCustomTags) {
+        addTag(inputValue);
+      }
+    } else if (e.key === "Backspace" && !inputValue && tags.length > 0) {
+      removeTag(tags[tags.length - 1]);
+    }
+  }, [inputValue, tags, addTag, removeTag, allowCustomTags, filteredSuggestions]);
+  const handlePaste = React21.useCallback((e) => {
+    const pastedText = e.clipboardData.getData("text");
+    if (TAG_SEPARATOR_PATTERN.test(pastedText)) {
+      e.preventDefault();
+      const newTags = pastedText.split(TAG_SEPARATOR_PATTERN).map((t) => t.trim()).filter((t) => t && !tags.includes(t));
+      if (newTags.length > 0) {
+        onChange([...tags, ...newTags]);
+      }
+    }
+  }, [tags, onChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(TextTagsInput_default.textTags, className),
+    style,
+    "data-loading": isLoading
+  }, error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Error loading suggestions: ", error.message), /* @__PURE__ */ React21__default.default.createElement(Combobox.Root, {
+    multiple: true,
+    value: tags,
+    onValueChange: handleValueChange,
+    inputValue,
+    onInputValueChange: handleInputValueChange
+  }, tags.length > 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.tagContainer
+  }, tags.map((tag) => /* @__PURE__ */ React21__default.default.createElement(TagItem, {
+    key: tag,
+    tag,
+    onRemove: removeTag
+  }))), /* @__PURE__ */ React21__default.default.createElement(Combobox.Input, {
+    className: TextTagsInput_default.input,
+    placeholder: tags.length > 0 ? "" : placeholder,
+    onKeyDown: handleKeyDown,
+    onPaste: handlePaste,
+    "aria-label": `Add ${propertyKey} tag`
+  }), /* @__PURE__ */ React21__default.default.createElement(Combobox.Portal, null, /* @__PURE__ */ React21__default.default.createElement(Combobox.Positioner, null, /* @__PURE__ */ React21__default.default.createElement(Combobox.Popup, null, filteredSuggestions.length === 0 ? allowCustomTags && inputValue.trim() ? /* @__PURE__ */ React21__default.default.createElement(Combobox.Empty, null, 'Press Enter to add "', inputValue, '"') : /* @__PURE__ */ React21__default.default.createElement(Combobox.Empty, null, suggestionLimit ? "No suggestions" : "Type to add a tag") : filteredSuggestions.map(({
+    value,
+    count
+  }) => /* @__PURE__ */ React21__default.default.createElement(Combobox.Item, {
+    key: value,
+    value
+  }, value, " (", count.toLocaleString(), ")")))))), isLoading && !!suggestionLimit && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.loadingMessage
+  }, "Loading suggestions..."));
+}
+var TextTagsInput = /* @__PURE__ */ React21.memo(TextTagsInputInner);
+
+// src/filter-list/base/inputs/TimelineInput.module.css
+var TimelineInput_default = {};
+
+// src/filter-list/base/inputs/TimelineInput.tsx
+function TimelineInputInner({
+  startDate,
+  endDate,
+  onChange,
+  className,
+  minDate,
+  maxDate
+}) {
+  const handleStartChange = React21.useCallback((e) => {
+    const date = parseDateFromInput(e.target.value);
+    onChange(date, endDate);
+  }, [onChange, endDate]);
+  const handleEndChange = React21.useCallback((e) => {
+    const date = parseDateFromInput(e.target.value);
+    onChange(startDate, date);
+  }, [onChange, startDate]);
+  const handleClear = React21.useCallback(() => {
+    onChange(void 0, void 0);
+  }, [onChange]);
+  const startInputMax = React21.useMemo(() => endDate ?? maxDate, [endDate, maxDate]);
+  const endInputMin = React21.useMemo(() => startDate ?? minDate, [startDate, minDate]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(TimelineInput_default.timeline, className)
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: TimelineInput_default.labels
+  }, /* @__PURE__ */ React21__default.default.createElement("span", null, formatDateForDisplay(startDate, "\u2014")), /* @__PURE__ */ React21__default.default.createElement("span", null, "to"), /* @__PURE__ */ React21__default.default.createElement("span", null, formatDateForDisplay(endDate, "\u2014")), (startDate || endDate) && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: TimelineInput_default.clearButton,
+    onClick: handleClear,
+    "aria-label": "Clear range"
+  }, "\xD7")), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: TimelineInput_default.brush
+  }, /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "date",
+    className: TimelineInput_default.input,
+    value: formatDateForInput(startDate),
+    onChange: handleStartChange,
+    min: minDate ? formatDateForInput(minDate) : void 0,
+    max: startInputMax ? formatDateForInput(startInputMax) : void 0,
+    "aria-label": "Start date"
+  }), /* @__PURE__ */ React21__default.default.createElement("span", null, "\u2014"), /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "date",
+    className: TimelineInput_default.input,
+    value: formatDateForInput(endDate),
+    onChange: handleEndChange,
+    min: endInputMin ? formatDateForInput(endInputMin) : void 0,
+    max: maxDate ? formatDateForInput(maxDate) : void 0,
+    "aria-label": "End date"
+  })));
+}
+var TimelineInput = /* @__PURE__ */ React21.memo(TimelineInputInner);
+
+// src/base-components/switch/Switch.module.css
+var Switch_default = {};
+
+// src/base-components/switch/Switch.tsx
+function _extends7() {
+  return _extends7 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends7.apply(null, arguments);
+}
+function Switch({
+  className,
+  thumbProps,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(_switch.Switch.Root, _extends7({
+    className: classnames7__default.default(Switch_default.osdkSwitchRoot, className)
+  }, rest), /* @__PURE__ */ React21__default.default.createElement(_switch.Switch.Thumb, _extends7({}, thumbProps, {
+    className: classnames7__default.default(Switch_default.osdkSwitchThumb, thumbProps?.className)
+  })));
+}
+
+// src/filter-list/base/inputs/ToggleInput.module.css
+var ToggleInput_default = {};
+
+// src/filter-list/base/inputs/ToggleInput.tsx
+function ToggleInputInner({
+  enabled,
+  onChange,
+  label,
+  className,
+  style
+}) {
+  const rootClassName = classnames7__default.default(ToggleInput_default.toggleInput, className);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: rootClassName,
+    style,
+    "data-enabled": enabled
+  }, /* @__PURE__ */ React21__default.default.createElement("label", {
+    className: ToggleInput_default.toggleLabel
+  }, /* @__PURE__ */ React21__default.default.createElement(Switch, {
+    checked: enabled,
+    onCheckedChange: onChange
+  }), label && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: ToggleInput_default.labelText
+  }, label)));
+}
+var ToggleInput = /* @__PURE__ */ React21.memo(ToggleInputInner);
+
+// src/filter-list/base/inputs/LinkedPropertyInput.tsx
+function LinkedPropertyInputInner({
+  objectSet,
+  definition,
+  filterState,
+  onFilterStateChanged,
+  className,
+  style
+}) {
+  const linkedObjectSet = React21.useMemo(() => objectSet.pivotTo(definition.linkName), [objectSet, definition.linkName]);
+  const linkedObjectType = linkedObjectSet.$objectSetInternals.def;
+  const linkedPropertyKey = definition.linkedPropertyKey;
+  const innerState = filterState?.type === "linkedProperty" ? filterState.linkedFilterState : void 0;
+  const isExcluding = innerState?.isExcluding ?? false;
+  const includeNull = innerState?.includeNull;
+  const wrappedOnChange = React21.useCallback((innerFilterState) => {
+    onFilterStateChanged({
+      type: "linkedProperty",
+      linkedFilterState: innerFilterState
+    });
+  }, [onFilterStateChanged]);
+  const onSelectChange = React21.useCallback((selectedValues) => {
+    wrappedOnChange({
+      type: "SELECT",
+      selectedValues,
+      isExcluding
+    });
+  }, [wrappedOnChange, isExcluding]);
+  const onSingleSelectChange = React21.useCallback((selectedValue) => {
+    wrappedOnChange({
+      type: "SELECT",
+      selectedValues: selectedValue !== void 0 ? [selectedValue] : [],
+      isExcluding
+    });
+  }, [wrappedOnChange, isExcluding]);
+  const onContainsTextChange = React21.useCallback((value) => {
+    wrappedOnChange({
+      type: "CONTAINS_TEXT",
+      value
+    });
+  }, [wrappedOnChange]);
+  const onToggleChange = React21.useCallback((enabled) => {
+    wrappedOnChange({
+      type: "TOGGLE",
+      enabled
+    });
+  }, [wrappedOnChange]);
+  const onNumberRangeChange = React21.useCallback((minValue, maxValue) => {
+    wrappedOnChange({
+      type: "NUMBER_RANGE",
+      minValue,
+      maxValue,
+      includeNull
+    });
+  }, [wrappedOnChange, includeNull]);
+  const onDateRangeChange = React21.useCallback((minValue, maxValue) => {
+    wrappedOnChange({
+      type: "DATE_RANGE",
+      minValue,
+      maxValue,
+      includeNull
+    });
+  }, [wrappedOnChange, includeNull]);
+  const onExactMatchChange = React21.useCallback((values) => {
+    wrappedOnChange({
+      type: "EXACT_MATCH",
+      values,
+      isExcluding
+    });
+  }, [wrappedOnChange, isExcluding]);
+  const onDateSelectChange = React21.useCallback((date) => {
+    wrappedOnChange({
+      type: "SELECT",
+      selectedValues: date !== void 0 ? [date] : [],
+      isExcluding
+    });
+  }, [wrappedOnChange, isExcluding]);
+  const onMultiDateChange = React21.useCallback((dates) => {
+    wrappedOnChange({
+      type: "SELECT",
+      selectedValues: dates
+    });
+  }, [wrappedOnChange]);
+  const onTimelineChange = React21.useCallback((start, end) => {
+    wrappedOnChange({
+      type: "TIMELINE",
+      startDate: start,
+      endDate: end,
+      isExcluding
+    });
+  }, [wrappedOnChange, isExcluding]);
+  const selectStringValues = React21.useMemo(() => innerState?.type === "SELECT" ? coerceToStringArray(innerState.selectedValues) : [], [innerState]);
+  const singleSelectValue = React21.useMemo(() => innerState?.type === "SELECT" ? coerceToString(innerState.selectedValues[0]) : void 0, [innerState]);
+  const exactMatchValues = React21.useMemo(() => innerState?.type === "EXACT_MATCH" ? coerceToStringArray(innerState.values) : [], [innerState]);
+  const selectedDates = React21.useMemo(() => innerState?.type === "SELECT" ? innerState.selectedValues.filter((v) => v instanceof Date) : [], [innerState]);
+  const selectedDate = React21.useMemo(() => innerState?.type === "SELECT" && innerState.selectedValues[0] instanceof Date ? innerState.selectedValues[0] : void 0, [innerState]);
+  const content = (() => {
+    switch (definition.linkedFilterComponent) {
+      case "CHECKBOX_LIST":
+        return /* @__PURE__ */ React21__default.default.createElement(CheckboxListInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          selectedValues: selectStringValues,
+          onChange: onSelectChange
+        });
+      case "MULTI_SELECT":
+        return /* @__PURE__ */ React21__default.default.createElement(MultiSelectInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          selectedValues: selectStringValues,
+          onChange: onSelectChange
+        });
+      case "SINGLE_SELECT":
+        return /* @__PURE__ */ React21__default.default.createElement(SingleSelectInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          selectedValue: singleSelectValue,
+          onChange: onSingleSelectChange
+        });
+      case "CONTAINS_TEXT":
+        return /* @__PURE__ */ React21__default.default.createElement(ContainsTextInput, {
+          value: innerState?.type === "CONTAINS_TEXT" ? innerState.value : void 0,
+          onChange: onContainsTextChange,
+          placeholder: `Search ${String(definition.linkedPropertyKey)}...`
+        });
+      case "TOGGLE":
+        return /* @__PURE__ */ React21__default.default.createElement(ToggleInput, {
+          enabled: innerState?.type === "TOGGLE" ? innerState.enabled : false,
+          onChange: onToggleChange
+        });
+      case "NUMBER_RANGE": {
+        const numberRange = innerState?.type === "NUMBER_RANGE" ? innerState : void 0;
+        return /* @__PURE__ */ React21__default.default.createElement(NumberRangeInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          minValue: numberRange?.minValue,
+          maxValue: numberRange?.maxValue,
+          onChange: onNumberRangeChange
+        });
+      }
+      case "DATE_RANGE": {
+        const dateRange = innerState?.type === "DATE_RANGE" ? innerState : void 0;
+        return /* @__PURE__ */ React21__default.default.createElement(DateRangeInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          minValue: dateRange?.minValue,
+          maxValue: dateRange?.maxValue,
+          onChange: onDateRangeChange
+        });
+      }
+      case "LISTOGRAM":
+        return /* @__PURE__ */ React21__default.default.createElement(ListogramInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          selectedValues: exactMatchValues,
+          onChange: onExactMatchChange
+        });
+      case "TEXT_TAGS":
+        return /* @__PURE__ */ React21__default.default.createElement(TextTagsInput, {
+          objectType: linkedObjectType,
+          objectSet: linkedObjectSet,
+          propertyKey: linkedPropertyKey,
+          tags: exactMatchValues,
+          onChange: onExactMatchChange
+        });
+      case "SINGLE_DATE":
+        return /* @__PURE__ */ React21__default.default.createElement(SingleDateInput, {
+          selectedDate,
+          onChange: onDateSelectChange,
+          showClearButton: true
+        });
+      case "MULTI_DATE":
+        return /* @__PURE__ */ React21__default.default.createElement(MultiDateInput, {
+          selectedDates,
+          onChange: onMultiDateChange,
+          showClearAll: true
+        });
+      case "TIMELINE": {
+        const timeline = innerState?.type === "TIMELINE" ? innerState : void 0;
+        return /* @__PURE__ */ React21__default.default.createElement(TimelineInput, {
+          startDate: timeline?.startDate,
+          endDate: timeline?.endDate,
+          onChange: onTimelineChange
+        });
+      }
+      default:
+        return assertUnreachable(definition.linkedFilterComponent);
+    }
+  })();
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(LinkedPropertyInput_default.linkedProperty, className),
+    style
+  }, content);
+}
+var LinkedPropertyInput = /* @__PURE__ */ React21.memo(LinkedPropertyInputInner);
+
+// src/filter-list/base/inputs/NullValueWrapper.module.css
+var NullValueWrapper_default = {};
+
+// src/filter-list/base/inputs/NullValueWrapper.tsx
+function NullValueWrapperInner({
+  objectType,
+  propertyKey,
+  includeNull = false,
+  onIncludeNullChange,
+  showNullCount = true,
+  children,
+  className,
+  style
+}) {
+  const nullCountAggregateOptions = React21.useMemo(() => createNullCountAggregateOptions(), []);
+  const nullWhereClause = React21.useMemo(() => createNullWhereClause(propertyKey), [propertyKey]);
+  const {
+    data: nullCountData,
+    isLoading,
+    error
+  } = experimental.useOsdkAggregation(objectType, {
+    where: nullWhereClause,
+    aggregate: nullCountAggregateOptions
+  });
+  const nullCount = React21.useMemo(() => {
+    if (!nullCountData) return 0;
+    const result = nullCountData;
+    if ("$count" in result && typeof result.$count === "number") {
+      return result.$count;
+    }
+    return 0;
+  }, [nullCountData]);
+  const handleToggle = React21.useCallback(() => {
+    onIncludeNullChange(!includeNull);
+  }, [includeNull, onIncludeNullChange]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(NullValueWrapper_default.nullWrapper, className),
+    style
+  }, children, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: NullValueWrapper_default.nullValueRow,
+    "data-checked": includeNull,
+    "data-loading": isLoading
+  }, /* @__PURE__ */ React21__default.default.createElement("label", {
+    className: NullValueWrapper_default.nullLabel
+  }, /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
+    checked: includeNull,
+    onCheckedChange: handleToggle
+  }), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: NullValueWrapper_default.nullLabelText
+  }, "No value")), showNullCount && !error && nullCount > 0 && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: NullValueWrapper_default.count
+  }, nullCount.toLocaleString())), error && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: shared_default.errorMessage
+  }, "Failed to load null count"));
+}
+var NullValueWrapper = /* @__PURE__ */ React21.memo(NullValueWrapperInner);
+
+// src/filter-list/base/FilterInput.tsx
+function FilterInputInner({
+  objectType,
+  objectSet,
+  definition,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(FilterInputContent, {
+    objectType,
+    objectSet,
+    definition,
+    filterState,
+    onFilterStateChanged,
+    whereClause
+  });
+}
+var FilterInput = /* @__PURE__ */ React21.memo(FilterInputInner);
+function FilterInputContent({
+  objectType,
+  objectSet,
+  definition,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  switch (definition.type) {
+    case "HAS_LINK":
+      return /* @__PURE__ */ React21__default.default.createElement(HasLinkInput, {
+        filterState,
+        onFilterStateChanged
+      });
+    case "LINKED_PROPERTY":
+      return /* @__PURE__ */ React21__default.default.createElement(LinkedPropertyInput, {
+        objectSet,
+        definition,
+        filterState,
+        onFilterStateChanged
+      });
+    case "KEYWORD_SEARCH":
+      return /* @__PURE__ */ React21__default.default.createElement(KeywordSearchInput, {
+        filterState,
+        onFilterStateChanged,
+        placeholder: definition.label ?? "Search..."
+      });
+    case "CUSTOM": {
+      if (!definition.renderInput) {
+        return /* @__PURE__ */ React21__default.default.createElement("div", {
+          "data-unsupported": "true"
+        }, "Custom filter missing renderInput");
+      }
+      const customFilterState = filterState?.type === "custom" ? filterState : definition.filterState;
+      return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, definition.renderInput({
+        objectSet,
+        filterState: customFilterState,
+        onFilterStateChanged: (state) => onFilterStateChanged(state)
+      }));
+    }
+    case "PROPERTY":
+      return /* @__PURE__ */ React21__default.default.createElement(PropertyFilterInput, {
+        objectType,
+        objectSet,
+        definition,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    default:
+      return /* @__PURE__ */ React21__default.default.createElement("div", {
+        "data-unsupported": "true"
+      }, "Unsupported filter type");
+  }
+}
+var HasLinkInput = /* @__PURE__ */ React21.memo(function HasLinkInput2({
+  filterState,
+  onFilterStateChanged
+}) {
+  const hasLink = filterState?.type === "hasLink" ? filterState.hasLink : false;
+  const handleChange = React21.useCallback((hasLink2) => {
+    onFilterStateChanged({
+      type: "hasLink",
+      hasLink: hasLink2
+    });
+  }, [onFilterStateChanged]);
+  return /* @__PURE__ */ React21__default.default.createElement(ToggleInput, {
+    enabled: hasLink,
+    onChange: handleChange
+  });
+});
+var KeywordSearchInput = /* @__PURE__ */ React21.memo(function KeywordSearchInput2({
+  filterState,
+  onFilterStateChanged,
+  placeholder
+}) {
+  const searchTerm = filterState?.type === "keywordSearch" ? filterState.searchTerm : void 0;
+  const operator = filterState?.type === "keywordSearch" ? filterState.operator : "AND";
+  const handleChange = React21.useCallback((newSearchTerm) => {
+    onFilterStateChanged({
+      type: "keywordSearch",
+      searchTerm: newSearchTerm ?? "",
+      operator
+    });
+  }, [onFilterStateChanged, operator]);
+  return /* @__PURE__ */ React21__default.default.createElement(ContainsTextInput, {
+    value: searchTerm,
+    onChange: handleChange,
+    placeholder
+  });
+});
+function PropertyFilterInputInner({
+  objectType,
+  objectSet,
+  definition,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  switch (definition.filterComponent) {
+    case "CHECKBOX_LIST":
+      return /* @__PURE__ */ React21__default.default.createElement(CheckboxListFilterInput, {
+        objectType,
+        objectSet,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    case "CONTAINS_TEXT":
+      return /* @__PURE__ */ React21__default.default.createElement(ContainsTextFilterInput, {
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged
+      });
+    case "TOGGLE":
+      return /* @__PURE__ */ React21__default.default.createElement(ToggleFilterInput, {
+        filterState,
+        onFilterStateChanged
+      });
+    case "NUMBER_RANGE":
+      return /* @__PURE__ */ React21__default.default.createElement(NumberRangeFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged
+      });
+    case "DATE_RANGE":
+      return /* @__PURE__ */ React21__default.default.createElement(DateRangeFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged
+      });
+    case "SINGLE_SELECT":
+      return /* @__PURE__ */ React21__default.default.createElement(SingleSelectFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    case "MULTI_SELECT":
+      return /* @__PURE__ */ React21__default.default.createElement(MultiSelectFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    case "SINGLE_DATE":
+      return /* @__PURE__ */ React21__default.default.createElement(SingleDateFilterInput, {
+        filterState,
+        onFilterStateChanged
+      });
+    case "MULTI_DATE":
+      return /* @__PURE__ */ React21__default.default.createElement(MultiDateFilterInput, {
+        filterState,
+        onFilterStateChanged
+      });
+    case "LISTOGRAM":
+      return /* @__PURE__ */ React21__default.default.createElement(ListogramFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    case "TEXT_TAGS":
+      return /* @__PURE__ */ React21__default.default.createElement(TextTagsFilterInput, {
+        objectType,
+        propertyKey: definition.key,
+        filterState,
+        onFilterStateChanged,
+        whereClause
+      });
+    case "TIMELINE":
+      return /* @__PURE__ */ React21__default.default.createElement(TimelineFilterInput, {
+        filterState,
+        onFilterStateChanged
+      });
+    default:
+      return /* @__PURE__ */ React21__default.default.createElement("div", {
+        "data-unsupported": "true"
+      }, "Unsupported filter component: ", definition.filterComponent);
+  }
+}
+var PropertyFilterInput = /* @__PURE__ */ React21.memo(PropertyFilterInputInner);
+function CheckboxListFilterInputInner({
+  objectType,
+  objectSet,
+  propertyKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  const selectedValues = React21.useMemo(() => filterState?.type === "SELECT" ? coerceToStringArray(filterState.selectedValues) : [], [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((newSelectedValues) => {
+    onFilterStateChanged({
+      type: "SELECT",
+      selectedValues: newSelectedValues,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(CheckboxListInput, {
+    objectType,
+    objectSet,
+    propertyKey,
+    selectedValues,
+    onChange: handleChange,
+    whereClause
+  });
+}
+var CheckboxListFilterInput = /* @__PURE__ */ React21.memo(CheckboxListFilterInputInner);
+var ContainsTextFilterInput = /* @__PURE__ */ React21.memo(function ContainsTextFilterInput2({
+  propertyKey,
+  filterState,
+  onFilterStateChanged
+}) {
+  const value = React21.useMemo(() => filterState?.type === "CONTAINS_TEXT" ? filterState.value : void 0, [filterState]);
+  const handleChange = React21.useCallback((value2) => {
+    onFilterStateChanged({
+      type: "CONTAINS_TEXT",
+      value: value2
+    });
+  }, [onFilterStateChanged]);
+  return /* @__PURE__ */ React21__default.default.createElement(ContainsTextInput, {
+    value,
+    onChange: handleChange,
+    placeholder: `Search ${propertyKey}...`
+  });
+});
+var ToggleFilterInput = /* @__PURE__ */ React21.memo(function ToggleFilterInput2({
+  filterState,
+  onFilterStateChanged
+}) {
+  const enabled = filterState?.type === "TOGGLE" ? filterState.enabled : false;
+  const handleChange = React21.useCallback((enabled2) => {
+    onFilterStateChanged({
+      type: "TOGGLE",
+      enabled: enabled2
+    });
+  }, [onFilterStateChanged]);
+  return /* @__PURE__ */ React21__default.default.createElement(ToggleInput, {
+    enabled,
+    onChange: handleChange
+  });
+});
+function NumberRangeFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged
+}) {
+  const numberRangeState = React21.useMemo(() => filterState?.type === "NUMBER_RANGE" ? filterState : void 0, [filterState]);
+  const includeNull = filterState?.includeNull;
+  const handleNullChange = React21.useCallback((includeNull2) => {
+    onFilterStateChanged({
+      type: "NUMBER_RANGE",
+      minValue: numberRangeState?.minValue,
+      maxValue: numberRangeState?.maxValue,
+      includeNull: includeNull2
+    });
+  }, [onFilterStateChanged, numberRangeState?.minValue, numberRangeState?.maxValue]);
+  const handleRangeChange = React21.useCallback((minValue, maxValue) => {
+    onFilterStateChanged({
+      type: "NUMBER_RANGE",
+      minValue,
+      maxValue,
+      includeNull
+    });
+  }, [onFilterStateChanged, includeNull]);
+  return /* @__PURE__ */ React21__default.default.createElement(NullValueWrapper, {
+    objectType,
+    propertyKey,
+    includeNull,
+    onIncludeNullChange: handleNullChange
+  }, /* @__PURE__ */ React21__default.default.createElement(NumberRangeInput, {
+    objectType,
+    propertyKey,
+    minValue: numberRangeState?.minValue,
+    maxValue: numberRangeState?.maxValue,
+    onChange: handleRangeChange
+  }));
+}
+var NumberRangeFilterInput = /* @__PURE__ */ React21.memo(NumberRangeFilterInputInner);
+function DateRangeFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged
+}) {
+  const dateRangeState = React21.useMemo(() => filterState?.type === "DATE_RANGE" ? filterState : void 0, [filterState]);
+  const includeNull = filterState?.includeNull;
+  const handleNullChange = React21.useCallback((includeNull2) => {
+    onFilterStateChanged({
+      type: "DATE_RANGE",
+      minValue: dateRangeState?.minValue,
+      maxValue: dateRangeState?.maxValue,
+      includeNull: includeNull2
+    });
+  }, [onFilterStateChanged, dateRangeState?.minValue, dateRangeState?.maxValue]);
+  const handleRangeChange = React21.useCallback((minValue, maxValue) => {
+    onFilterStateChanged({
+      type: "DATE_RANGE",
+      minValue,
+      maxValue,
+      includeNull
+    });
+  }, [onFilterStateChanged, includeNull]);
+  return /* @__PURE__ */ React21__default.default.createElement(NullValueWrapper, {
+    objectType,
+    propertyKey,
+    includeNull,
+    onIncludeNullChange: handleNullChange
+  }, /* @__PURE__ */ React21__default.default.createElement(DateRangeInput, {
+    objectType,
+    propertyKey,
+    minValue: dateRangeState?.minValue,
+    maxValue: dateRangeState?.maxValue,
+    onChange: handleRangeChange
+  }));
+}
+var DateRangeFilterInput = /* @__PURE__ */ React21.memo(DateRangeFilterInputInner);
+function SingleSelectFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  const selectedValue = React21.useMemo(() => filterState?.type === "SELECT" ? coerceToString(filterState.selectedValues[0]) : void 0, [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((value) => {
+    onFilterStateChanged({
+      type: "SELECT",
+      selectedValues: value !== void 0 ? [value] : [],
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(SingleSelectInput, {
+    objectType,
+    propertyKey,
+    selectedValue,
+    onChange: handleChange,
+    whereClause
+  });
+}
+var SingleSelectFilterInput = /* @__PURE__ */ React21.memo(SingleSelectFilterInputInner);
+function MultiSelectFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  const selectedValues = React21.useMemo(() => filterState?.type === "SELECT" ? coerceToStringArray(filterState.selectedValues) : [], [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((selectedValues2) => {
+    onFilterStateChanged({
+      type: "SELECT",
+      selectedValues: selectedValues2,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(MultiSelectInput, {
+    objectType,
+    propertyKey,
+    selectedValues,
+    onChange: handleChange,
+    whereClause
+  });
+}
+var MultiSelectFilterInput = /* @__PURE__ */ React21.memo(MultiSelectFilterInputInner);
+var SingleDateFilterInput = /* @__PURE__ */ React21.memo(function SingleDateFilterInput2({
+  filterState,
+  onFilterStateChanged
+}) {
+  const selectedDate = React21.useMemo(() => filterState?.type === "SELECT" ? filterState.selectedValues[0] instanceof Date ? filterState.selectedValues[0] : void 0 : void 0, [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((selectedDate2) => {
+    onFilterStateChanged({
+      type: "SELECT",
+      selectedValues: selectedDate2 !== void 0 ? [selectedDate2] : [],
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(SingleDateInput, {
+    selectedDate,
+    onChange: handleChange
+  });
+});
+var MultiDateFilterInput = /* @__PURE__ */ React21.memo(function MultiDateFilterInput2({
+  filterState,
+  onFilterStateChanged
+}) {
+  const selectedDates = React21.useMemo(() => filterState?.type === "SELECT" ? filterState.selectedValues.filter((v) => v instanceof Date) : [], [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((selectedDates2) => {
+    onFilterStateChanged({
+      type: "SELECT",
+      selectedValues: selectedDates2,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(MultiDateInput, {
+    selectedDates,
+    onChange: handleChange
+  });
+});
+function ListogramFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  const selectedValues = React21.useMemo(() => filterState?.type === "EXACT_MATCH" ? coerceToStringArray(filterState.values) : [], [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((values) => {
+    onFilterStateChanged({
+      type: "EXACT_MATCH",
+      values,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(ListogramInput, {
+    objectType,
+    propertyKey,
+    selectedValues,
+    onChange: handleChange,
+    whereClause
+  });
+}
+var ListogramFilterInput = /* @__PURE__ */ React21.memo(ListogramFilterInputInner);
+function TextTagsFilterInputInner({
+  objectType,
+  propertyKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause
+}) {
+  const tags = React21.useMemo(() => filterState?.type === "EXACT_MATCH" ? coerceToStringArray(filterState.values) : [], [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((values) => {
+    onFilterStateChanged({
+      type: "EXACT_MATCH",
+      values,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(TextTagsInput, {
+    objectType,
+    propertyKey,
+    tags,
+    onChange: handleChange,
+    whereClause
+  });
+}
+var TextTagsFilterInput = /* @__PURE__ */ React21.memo(TextTagsFilterInputInner);
+var TimelineFilterInput = /* @__PURE__ */ React21.memo(function TimelineFilterInput2({
+  filterState,
+  onFilterStateChanged
+}) {
+  const {
+    startDate,
+    endDate
+  } = React21.useMemo(() => filterState?.type === "TIMELINE" ? {
+    startDate: filterState.startDate,
+    endDate: filterState.endDate
+  } : {
+    startDate: void 0,
+    endDate: void 0
+  }, [filterState]);
+  const isExcluding = filterState?.isExcluding ?? false;
+  const handleChange = React21.useCallback((startDate2, endDate2) => {
+    onFilterStateChanged({
+      type: "TIMELINE",
+      startDate: startDate2,
+      endDate: endDate2,
+      isExcluding
+    });
+  }, [onFilterStateChanged, isExcluding]);
+  return /* @__PURE__ */ React21__default.default.createElement(TimelineInput, {
+    startDate,
+    endDate,
+    onChange: handleChange
+  });
+});
+
+// src/filter-list/base/FilterListItem.module.css
+var FilterListItem_default = {};
+
+// src/filter-list/base/FilterListItem.tsx
+function FilterListItemInner({
+  objectType,
+  objectSet,
+  definition,
+  filterKey,
+  filterState,
+  onFilterStateChanged,
+  whereClause,
+  className,
+  style
+}) {
+  const label = getLabel(definition);
+  const handleFilterStateChanged = React21.useCallback((newState) => {
+    onFilterStateChanged(filterKey, newState);
+  }, [filterKey, onFilterStateChanged]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(FilterListItem_default.filterItem, className),
+    style,
+    "data-filter-type": definition.type
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: FilterListItem_default.itemHeader
+  }, /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: FilterListItem_default.itemLabel
+  }, label)), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: FilterListItem_default.itemContent
+  }, /* @__PURE__ */ React21__default.default.createElement(ErrorBoundary, {
+    errorMessage: "Error loading filter"
+  }, /* @__PURE__ */ React21__default.default.createElement(FilterInput, {
+    objectType,
+    objectSet,
+    definition,
+    filterState,
+    onFilterStateChanged: handleFilterStateChanged,
+    whereClause
+  }))));
+}
+var FilterListItem = /* @__PURE__ */ React21.memo(FilterListItemInner);
+function getLabel(definition) {
+  if ("label" in definition && definition.label) {
+    return definition.label;
+  }
+  switch (definition.type) {
+    case "PROPERTY":
+      return definition.key;
+    case "HAS_LINK":
+    case "LINKED_PROPERTY":
+      return definition.linkName;
+    case "KEYWORD_SEARCH":
+      return "Search";
+    case "CUSTOM":
+      return definition.key;
+  }
+}
+
+// src/filter-list/base/FilterListContent.tsx
+function FilterListContent({
+  objectType,
+  objectSet,
+  filterDefinitions,
+  filterStates,
+  onFilterStateChanged,
+  whereClause,
+  className,
+  style
+}) {
+  if (!filterDefinitions || filterDefinitions.length === 0) {
+    return /* @__PURE__ */ React21__default.default.createElement("div", {
+      className: classnames7__default.default(FilterListContent_default.content, className),
+      style,
+      "data-empty": "true"
+    });
+  }
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(FilterListContent_default.content, className),
+    style
+  }, filterDefinitions.map((definition, index) => {
+    const filterKey = getFilterKey(definition);
+    const state = filterStates.get(filterKey);
+    return /* @__PURE__ */ React21__default.default.createElement(FilterListItem, {
+      key: filterKey,
+      objectType,
+      objectSet,
+      definition,
+      filterKey,
+      filterState: state,
+      onFilterStateChanged,
+      whereClause
+    });
+  }));
+}
+
+// src/filter-list/base/FilterListHeader.module.css
+var FilterListHeader_default = {};
+
+// src/filter-list/base/FilterListHeader.tsx
+function FilterListHeaderInner({
+  title,
+  titleIcon,
+  collapsed = false,
+  onCollapsedChange,
+  showResetButton,
+  onReset,
+  showActiveFilterCount,
+  activeFilterCount = 0
+}) {
+  const showCollapseButton = onCollapsedChange != null;
+  const handleCollapseClick = React21.useCallback(() => {
+    onCollapsedChange?.(!collapsed);
+  }, [onCollapsedChange, collapsed]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: FilterListHeader_default.header
+  }, showCollapseButton && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: FilterListHeader_default.collapseButton,
+    onClick: handleCollapseClick,
+    "aria-expanded": !collapsed,
+    "aria-label": collapsed ? "Expand filters" : "Collapse filters"
+  }, /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: FilterListHeader_default.collapseIcon,
+    "data-collapsed": collapsed
+  })), !collapsed && /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: FilterListHeader_default.titleContainer
+  }, titleIcon && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: FilterListHeader_default.titleIcon
+  }, titleIcon), title && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: FilterListHeader_default.title
+  }, title), showActiveFilterCount && activeFilterCount > 0 && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: FilterListHeader_default.activeCount
+  }, "(", activeFilterCount, ")")), showResetButton && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: FilterListHeader_default.resetButton,
+    onClick: onReset,
+    disabled: activeFilterCount === 0
+  }, "Reset")));
+}
+var FilterListHeader = /* @__PURE__ */ React21.memo(FilterListHeaderInner);
+
+// src/filter-list/base/FilterList.tsx
+function FilterList(props) {
+  const {
+    objectSet,
+    title,
+    titleIcon,
+    filterDefinitions,
+    showResetButton = false,
+    onReset,
+    onFilterAdded,
+    showActiveFilterCount = false,
+    className,
+    renderAddFilterButton
+  } = props;
+  const objectType = objectSet.$objectSetInternals.def;
+  const {
+    filterStates,
+    setFilterState,
+    whereClause,
+    activeFilterCount,
+    reset
+  } = useFilterListState(props);
+  const handleReset = React21.useCallback(() => {
+    reset();
+    onReset?.();
+  }, [reset, onReset]);
+  const visibleFilterDefinitions = React21.useMemo(() => {
+    if (!filterDefinitions) return void 0;
+    return filterDefinitions.filter((def) => def.isVisible !== false);
+  }, [filterDefinitions]);
+  const showHeader = title || titleIcon || showResetButton || showActiveFilterCount;
+  const showAddButton = renderAddFilterButton != null || onFilterAdded != null;
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(FilterList_default.filterList, className),
+    "data-active-count": activeFilterCount
+  }, showHeader && /* @__PURE__ */ React21__default.default.createElement(FilterListHeader, {
+    title,
+    titleIcon,
+    showResetButton,
+    onReset: handleReset,
+    showActiveFilterCount,
+    activeFilterCount
+  }), /* @__PURE__ */ React21__default.default.createElement(FilterListContent, {
+    objectType,
+    objectSet,
+    filterDefinitions: visibleFilterDefinitions,
+    filterStates,
+    onFilterStateChanged: setFilterState,
+    whereClause
+  }), showAddButton && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: FilterList_default.addButtonContainer
+  }, renderAddFilterButton ? renderAddFilterButton() : /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    type: "button",
+    className: FilterList_default.addButton
+  }, "+ Add filter")));
+}
+
+// src/object-table/EditableCell.module.css
+var EditableCell_default = {};
+
+// src/object-table/EditableCell.tsx
+var NUMBER_TYPES = ["double", "integer", "long", "float", "decimal", "byte", "short"];
+function valueToString(value) {
+  if (value == null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function parseValueByType(value, dataType) {
+  if (!dataType || !NUMBER_TYPES.includes(dataType)) {
+    return value;
+  }
+  if (value === "") {
+    return null;
+  }
+  const parsedNumber = Number(value);
+  if (isNaN(parsedNumber)) {
+    return value;
+  }
+  return parsedNumber;
+}
+function EditableCell({
+  initialValue,
+  currentValue,
+  cellId,
+  dataType,
+  onCellEdit
+}) {
+  const [inputValue, setInputValue] = React21.useState(valueToString(currentValue));
+  const isCancelled = React21.useRef(false);
+  React21.useEffect(() => {
+    setInputValue(valueToString(currentValue));
+  }, [currentValue]);
+  const handleBlur = React21.useCallback(() => {
+    if (isCancelled.current) {
+      isCancelled.current = false;
+      return;
+    }
+    const parsedValue = parseValueByType(inputValue, dataType);
+    onCellEdit?.(cellId, {
+      newValue: parsedValue,
+      oldValue: initialValue
+    });
+  }, [inputValue, initialValue, onCellEdit, cellId, dataType]);
+  const handleChange = React21.useCallback((value) => {
+    setInputValue(value);
+  }, []);
+  const handleKeyDown = React21.useCallback((e) => {
+    if (e.key === "Enter") {
+      e.currentTarget.blur();
+    }
+    if (e.key === "Escape") {
+      isCancelled.current = true;
+      setInputValue(valueToString(currentValue));
+      e.currentTarget.blur();
+    }
+  }, [currentValue]);
+  const inputType = dataType && NUMBER_TYPES.includes(dataType) ? "number" : "text";
+  return /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    className: EditableCell_default.osdkEditableInput,
+    type: inputType,
+    value: inputValue,
+    onValueChange: handleChange,
+    onBlur: handleBlur,
+    onKeyDown: handleKeyDown
+  });
+}
+
+// src/object-table/utils/getCellId.ts
+function getCellId(cellIdentifier) {
+  return JSON.stringify(cellIdentifier);
+}
+function getCellIdentifier(cellId) {
+  const parsed = JSON.parse(cellId);
+  if (typeof parsed === "object" && parsed != null && "rowId" in parsed && "columnId" in parsed) {
+    return parsed;
+  }
+  throw new Error("Parsed cellId does not have required properties");
+}
+
+// src/object-table/DefaultCellRenderer.tsx
+function renderDefaultCell(cellContext) {
+  const meta = cellContext.table.options.meta;
+  const columnMeta = cellContext.column.columnDef.meta;
+  if (!columnMeta?.editable || !meta?.onCellEdit) {
+    return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, cellContext.getValue());
+  }
+  const rowId = cellContext.row.id;
+  const columnId = cellContext.column.id;
+  const cellId = getCellId({
+    rowId,
+    columnId
+  });
+  const cellEdits = meta.cellEdits;
+  const editedValue = cellEdits?.[cellId];
+  const currentValue = editedValue?.newValue ?? cellContext.getValue();
+  return /* @__PURE__ */ React21__default.default.createElement(EditableCell, {
+    initialValue: cellContext.getValue(),
+    currentValue,
+    cellId,
+    dataType: columnMeta?.dataType,
+    onCellEdit: meta.onCellEdit
+  });
+}
 
-// src/object-table/ObjectTable.tsx
+// src/object-table/hooks/useColumnDefs.ts
 function useColumnDefs(objectType, columnDefinitions) {
   const {
     metadata,
     loading,
     error
   } = react.useOsdkMetadata(objectType);
-  const columns = React7.useMemo(() => {
+  const columns = React21.useMemo(() => {
     const objectProperties = metadata?.properties;
     if (columnDefinitions) {
       return getColumnsFromColumnDefinitions(columnDefinitions, objectProperties);
@@ -46,15 +2894,24 @@ function getColumnsFromColumnDefinitions(columnDefinitions, objectProperties) {
       resizable,
       orderable,
       filterable,
+      editable,
       renderCell,
-      renderHeader
+      renderHeader,
+      columnName
     } = col;
     const propertyMetadata = locator.type === "property" ? objectProperties?.[locator.id] : void 0;
     const colKey = locator.id;
+    const dataType = propertyMetadata?.type && typeof propertyMetadata.type === "string" ? propertyMetadata.type : void 0;
     const colDef = {
       id: colKey,
       accessorKey: colKey,
-      header: renderHeader ?? propertyMetadata?.displayName,
+      header: renderHeader ?? (columnName || propertyMetadata?.displayName),
+      meta: {
+        columnName: columnName || propertyMetadata?.displayName,
+        isVisible: col.isVisible !== false,
+        editable,
+        dataType
+      },
       size: width,
       ...minWidth ? {
         minSize: minWidth
@@ -67,7 +2924,10 @@ function getColumnsFromColumnDefinitions(columnDefinitions, objectProperties) {
       enableColumnFilter: filterable,
       cell: (cellContext) => {
         const object = cellContext.row.original;
-        return renderCell ? renderCell(object, locator) : cellContext.getValue();
+        if (renderCell) {
+          return renderCell(object, locator);
+        }
+        return renderDefaultCell(cellContext);
       }
     };
     return colDef;
@@ -93,11 +2953,11 @@ var useColumnPinning = ({
   hasSelectionColumn,
   onColumnsPinnedChanged
 }) => {
-  const [columnPinning, setColumnPinning] = React7.useState({
+  const [columnPinning, setColumnPinning] = React21.useState({
     left: [],
     right: []
   });
-  React7.useEffect(() => {
+  React21.useEffect(() => {
     const defaultState = getColumnPinningStateFromColumnDefs(columnDefinitions);
     const selectionCol = hasSelectionColumn ? [SELECTION_COLUMN_ID] : [];
     setColumnPinning({
@@ -105,7 +2965,7 @@ var useColumnPinning = ({
       right: [...defaultState.right ?? []]
     });
   }, [columnDefinitions, hasSelectionColumn]);
-  const onColumnPinningChange = React7.useCallback((updater) => {
+  const onColumnPinningChange = React21.useCallback((updater) => {
     setColumnPinning((prev) => {
       const newPinning = typeof updater === "function" ? updater(prev) : updater;
       if (onColumnsPinnedChanged) {
@@ -159,32 +3019,125 @@ function convertColumnPinningStateToArray(pinningState) {
     pinned: "right"
   }))];
 }
-var useColumnVisibility = ({
-  columnDefinitions
+var useColumnResize = ({
+  onColumnResize
 }) => {
-  const columnVisibility = React7.useMemo(() => {
-    if (columnDefinitions) {
-      const colVisibility = columnDefinitions.reduce((acc, colDef) => {
-        if (colDef.isVisible !== void 0) {
-          const {
-            locator
-          } = colDef;
-          const colKey = locator.id;
-          return {
-            ...acc,
-            [colKey]: colDef.isVisible
-          };
+  const [columnSizing, setColumnSizing] = React21.useState({});
+  const onColumnSizingChange = React21.useCallback((updater) => {
+    setColumnSizing((prev) => {
+      const newState = typeof updater === "function" ? updater(prev) : updater;
+      if (onColumnResize) {
+        for (const columnId of Object.keys(newState)) {
+          if (newState[columnId] !== prev[columnId]) {
+            onColumnResize(columnId, newState[columnId]);
+          }
+        }
+        for (const columnId of Object.keys(prev)) {
+          if (!(columnId in newState)) {
+            onColumnResize(columnId, null);
+          }
         }
-        return acc;
-      }, {});
-      return colVisibility;
+      }
+      return newState;
+    });
+  }, [onColumnResize]);
+  return {
+    columnSizing,
+    onColumnSizingChange
+  };
+};
+var useColumnVisibility = ({
+  allColumns,
+  onColumnVisibilityChanged
+}) => {
+  const [columnVisibility, setColumnVisibility] = React21.useState(() => getColumnVisibilityState(allColumns));
+  const [columnOrder, setColumnOrder] = React21.useState(() => getColumnOrder(allColumns));
+  React21.useEffect(() => {
+    setColumnVisibility(getColumnVisibilityState(allColumns));
+  }, [allColumns]);
+  React21.useEffect(() => {
+    setColumnOrder(getColumnOrder(allColumns));
+  }, [allColumns]);
+  const onColumnVisibilityChange = React21.useCallback((updaterOrValue) => {
+    setColumnVisibility((prev) => {
+      const newState = typeof updaterOrValue === "function" ? updaterOrValue(prev) : updaterOrValue;
+      if (onColumnVisibilityChanged) {
+        const changes = Object.entries(newState).map(([columnId, isVisible]) => ({
+          columnId,
+          isVisible
+        }));
+        onColumnVisibilityChanged(changes);
+      }
+      return newState;
+    });
+  }, [onColumnVisibilityChanged]);
+  const onColumnOrderChange = React21.useCallback((updaterOrValue) => {
+    setColumnOrder((prev) => {
+      const newState = typeof updaterOrValue === "function" ? updaterOrValue(prev) : updaterOrValue;
+      return newState;
+    });
+  }, []);
+  return {
+    columnVisibility,
+    onColumnVisibilityChange,
+    columnOrder,
+    onColumnOrderChange
+  };
+};
+var getColumnVisibilityState = (allColumns) => {
+  return allColumns.reduce((acc, col) => {
+    const colId = col.id ?? col.accessorKey;
+    if (colId) {
+      return {
+        ...acc,
+        [colId]: col.meta?.isVisible !== false
+      };
     }
-  }, [columnDefinitions]);
-  return columnVisibility;
+    return acc;
+  }, {});
 };
+var getColumnOrder = (allColumns) => {
+  return allColumns.map((col) => col.id ?? col.accessorKey).filter((id) => id != null);
+};
+function useEditableTable({
+  onCellValueChanged,
+  onSubmitEdits
+}) {
+  const [cellEdits, setCellEdits] = React21.useState({});
+  const handleCellEdit = React21.useCallback((cellId, state) => {
+    const cellIdentifier = getCellIdentifier(cellId);
+    if (state.newValue === state.oldValue) {
+      setCellEdits((prev) => {
+        const {
+          [cellId]: _,
+          ...rest
+        } = prev;
+        return rest;
+      });
+    } else {
+      setCellEdits((prev) => ({
+        ...prev,
+        [cellId]: state
+      }));
+    }
+    onCellValueChanged?.(cellIdentifier, state);
+  }, [onCellValueChanged]);
+  const clearEdits = React21.useCallback(() => {
+    setCellEdits({});
+  }, []);
+  const handleSubmitEdits = React21.useCallback(async () => {
+    await onSubmitEdits?.(cellEdits);
+  }, [cellEdits, onSubmitEdits]);
+  return {
+    cellEdits,
+    handleCellEdit,
+    handleSubmitEdits,
+    clearEdits
+  };
+}
 var PAGE_SIZE = 50;
-function useObjectTableData(objectOrInterfaceType, columnDefinitions, filter, sorting) {
-  const orderBy = React7.useMemo(() => {
+function useObjectTableData(objectOrInterfaceType, columnDefinitions, filter, sorting, objectSet, objectSetOptions) {
+  const orderBy = React21.useMemo(() => {
     if (!sorting || sorting.length === 0) {
       return void 0;
     }
@@ -193,7 +3146,7 @@ function useObjectTableData(objectOrInterfaceType, columnDefinitions, filter, so
       return acc;
     }, {});
   }, [sorting]);
-  const withProperties = React7.useMemo(() => {
+  const withProperties = React21.useMemo(() => {
     if (!columnDefinitions) {
       return;
     }
@@ -210,12 +3163,37 @@ function useObjectTableData(objectOrInterfaceType, columnDefinitions, filter, so
       };
     }, {});
   }, [columnDefinitions]);
-  return experimental.useOsdkObjects(objectOrInterfaceType, {
+  const isObjectType = objectOrInterfaceType.type === "object";
+  const shouldUseObjectSet = !!objectSet && isObjectType;
+  const objectSetResult = experimental.useObjectSet(shouldUseObjectSet ? objectSet : void 0, {
+    ...objectSetOptions,
+    withProperties,
+    where: filter,
+    orderBy,
+    pageSize: PAGE_SIZE,
+    enabled: shouldUseObjectSet
+  });
+  const osdkObjectsResult = experimental.useOsdkObjects(objectOrInterfaceType, {
     withProperties,
     pageSize: PAGE_SIZE,
     where: filter,
-    orderBy
+    orderBy,
+    enabled: !shouldUseObjectSet
   });
+  if (shouldUseObjectSet) {
+    console.debug("Using useObjectSet for data fetching in ObjectTable because objectSet is provided and objectType is an object.");
+    return {
+      data: objectSetResult.data,
+      fetchMore: objectSetResult.fetchMore,
+      isLoading: objectSetResult.isLoading,
+      error: objectSetResult.error,
+      totalCount: objectSetResult.totalCount,
+      isOptimistic: false
+      // ObjectSet doesn't support optimistic updates
+    };
+  }
+  console.debug("Using useOsdkObjects for data fetching in ObjectTable because objectSet is not provided or objectType is an interface.");
+  return osdkObjectsResult;
 }
 
 // src/object-table/utils/getRowId.ts
@@ -231,31 +3209,31 @@ function useRowSelection({
   onRowSelection,
   data
 }) {
-  const [internalRowSelection, setInternalRowSelection] = React7.useState({});
-  const [lastSelectedRowIndex, setLastSelectedRowIndex] = React7.useState(null);
+  const [internalRowSelection, setInternalRowSelection] = React21.useState({});
+  const [lastSelectedRowIndex, setLastSelectedRowIndex] = React21.useState(null);
   const isControlled = selectedRows !== void 0;
-  const isSelectionEnabled = selectionMode !== "none";
-  const rowSelectionState = React7.useMemo(() => {
-    if (!isSelectionEnabled) return {};
+  const enableRowSelection = selectionMode !== "none";
+  const rowSelectionState = React21.useMemo(() => {
+    if (!enableRowSelection) return {};
     if (isControlled && selectedRows) {
       return getRowSelectionState(selectedRows);
     }
     return internalRowSelection;
-  }, [isSelectionEnabled, isControlled, selectedRows, internalRowSelection]);
+  }, [enableRowSelection, isControlled, selectedRows, internalRowSelection]);
   const selectedCount = Object.values(rowSelectionState).filter(Boolean).length;
   const totalCount = data?.length ?? 0;
   const isAllSelected = totalCount > 0 && selectedCount === totalCount;
   const hasSelection = selectedCount > 0;
-  const onToggleAll = React7.useCallback(() => {
-    if (!isSelectionEnabled || !data) return;
+  const onToggleAll = React21.useCallback(() => {
+    if (!enableRowSelection || !data) return;
     const newSelectedRows = isAllSelected ? [] : data.map((item) => item.$primaryKey);
     if (!isControlled) {
       setInternalRowSelection(getRowSelectionState(newSelectedRows));
     }
     onRowSelection?.(newSelectedRows);
-  }, [isSelectionEnabled, data, isAllSelected, isControlled, onRowSelection]);
-  const onToggleRow = React7.useCallback((rowId, rowIndex, isShiftClick = false) => {
-    if (!isSelectionEnabled || !data) return;
+  }, [enableRowSelection, data, isAllSelected, isControlled, onRowSelection]);
+  const onToggleRow = React21.useCallback((rowId, rowIndex, isShiftClick = false) => {
+    if (!enableRowSelection || !data) return;
     let newSelectedRows = [];
     if (selectionMode === "single") {
       newSelectedRows = getSingleSelectionRows({
@@ -264,7 +3242,6 @@ function useRowSelection({
         data,
         rowSelectionState
       });
-      setLastSelectedRowIndex(rowIndex);
     } else {
       if (isShiftClick && lastSelectedRowIndex != null) {
         newSelectedRows = getRangeSelectionRows({
@@ -273,23 +3250,31 @@ function useRowSelection({
           lastSelectedRowIndex,
           rowSelectionState
         });
+        setLastSelectedRowIndex(rowIndex);
       } else {
         newSelectedRows = getMultipleSelectionRows({
           rowIndex,
           data,
           rowSelectionState
         });
+        if (!isCurrentlySelected({
+          rowIndex,
+          data,
+          rowSelectionState
+        })) {
+          setLastSelectedRowIndex(rowIndex);
+        }
       }
-      setLastSelectedRowIndex(rowIndex);
     }
     if (!isControlled) {
       setInternalRowSelection(getRowSelectionState(newSelectedRows));
     }
     onRowSelection?.(newSelectedRows);
-  }, [isSelectionEnabled, data, selectionMode, lastSelectedRowIndex, isControlled, rowSelectionState, onRowSelection]);
+  }, [enableRowSelection, data, selectionMode, lastSelectedRowIndex, isControlled, rowSelectionState, onRowSelection]);
   return {
     rowSelection: rowSelectionState,
     isAllSelected,
+    enableRowSelection,
     hasSelection,
     onToggleAll,
     onToggleRow
@@ -325,6 +3310,15 @@ function getRangeSelectionRows({
   }
   return [];
 }
+function isCurrentlySelected({
+  rowIndex,
+  data,
+  rowSelectionState
+}) {
+  const primaryKey = data[rowIndex].$primaryKey;
+  const currentlySelected = getSelectedPrimaryKeys(rowSelectionState, data);
+  return currentlySelected.includes(primaryKey);
+}
 function getMultipleSelectionRows({
   rowIndex,
   data,
@@ -332,7 +3326,11 @@ function getMultipleSelectionRows({
 }) {
   const primaryKey = data[rowIndex].$primaryKey;
   const currentlySelected = getSelectedPrimaryKeys(rowSelectionState, data);
-  const newSelectedRows = currentlySelected.includes(primaryKey) ? currentlySelected.filter((i) => i !== primaryKey) : [...currentlySelected, primaryKey];
+  const newSelectedRows = isCurrentlySelected({
+    rowIndex,
+    data,
+    rowSelectionState
+  }) ? currentlySelected.filter((i) => i !== primaryKey) : [...currentlySelected, primaryKey];
   return newSelectedRows;
 }
 function getRowsInRange(data, startIndex, endIndex) {
@@ -356,45 +3354,12 @@ function getRowSelectionState(primaryKeys) {
 function getSelectedPrimaryKeys(selectionState, data) {
   return data.filter((item) => selectionState[getRowId(item)]).map((item) => item.$primaryKey);
 }
-
-// src/base-components/checkbox/Checkbox.module.css
-var Checkbox_default = {};
-
-// src/base-components/checkbox/Checkbox.tsx
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function(n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
-function Checkbox({
-  indeterminate,
-  className,
-  indicatorProps,
-  ...rest
-}) {
-  return /* @__PURE__ */ React7__default.default.createElement(checkbox.Checkbox.Root, _extends({
-    className: classNames2__default.default(Checkbox_default.osdkCheckboxRoot, className),
-    indeterminate
-  }, rest), /* @__PURE__ */ React7__default.default.createElement(checkbox.Checkbox.Indicator, _extends({}, indicatorProps, {
-    className: classNames2__default.default(Checkbox_default.osdkCheckboxIndicator, indicatorProps?.className)
-  }), indeterminate ? /* @__PURE__ */ React7__default.default.createElement(icons.Minus, {
-    color: "currentColor"
-  }) : /* @__PURE__ */ React7__default.default.createElement(icons.Tick, {
-    color: "currentColor"
-  })));
-}
-
-// src/object-table/SelectionCells.tsx
 function SelectionHeaderCell({
   isAllSelected,
   hasSelection,
   onToggleAll
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement(Checkbox, {
+  return /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
     indeterminate: hasSelection && !isAllSelected,
     checked: isAllSelected,
     onCheckedChange: onToggleAll,
@@ -405,15 +3370,24 @@ function SelectionCell({
   row,
   onToggleRow
 }) {
-  const handleClick = React7.useCallback((event) => {
+  const handleClick = React21.useCallback((event) => {
+    event.stopPropagation();
     const isShiftClick = event.shiftKey;
     onToggleRow(row.id, row.index, isShiftClick);
-  }, [row, onToggleRow]);
-  return /* @__PURE__ */ React7__default.default.createElement(Checkbox, {
-    checked: row.getIsSelected(),
+  }, [onToggleRow, row.id, row.index]);
+  const handleKeyDown = React21.useCallback((event) => {
+    if (event.key === "Enter") {
+      const isShiftClick = event.shiftKey;
+      onToggleRow(row.id, row.index, isShiftClick);
+    }
+  }, [onToggleRow, row.id, row.index]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
     onClick: handleClick,
+    onKeyDown: handleKeyDown
+  }, /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
+    checked: row.getIsSelected(),
     "aria-label": `Select row ${row.index + 1}`
-  });
+  }));
 }
 
 // src/object-table/hooks/useSelectionColumn.tsx
@@ -424,20 +3398,28 @@ var useSelectionColumn = ({
   onToggleAll,
   onToggleRow
 }) => {
-  const selectionColumn = React7.useMemo(() => {
+  const isAllSelectedRef = React21.useRef(isAllSelected);
+  isAllSelectedRef.current = isAllSelected;
+  const hasSelectionRef = React21.useRef(hasSelection);
+  hasSelectionRef.current = hasSelection;
+  const onToggleAllRef = React21.useRef(onToggleAll);
+  onToggleAllRef.current = onToggleAll;
+  const onToggleRowRef = React21.useRef(onToggleRow);
+  onToggleRowRef.current = onToggleRow;
+  const selectionColumn = React21.useMemo(() => {
     if (selectionMode === "none") return null;
     const colDef = {
       id: SELECTION_COLUMN_ID,
-      header: () => selectionMode === "multiple" ? /* @__PURE__ */ React7__default.default.createElement(SelectionHeaderCell, {
-        isAllSelected,
-        hasSelection,
-        onToggleAll
+      header: () => selectionMode === "multiple" ? /* @__PURE__ */ React21__default.default.createElement(SelectionHeaderCell, {
+        isAllSelected: isAllSelectedRef.current,
+        hasSelection: hasSelectionRef.current,
+        onToggleAll: onToggleAllRef.current
       }) : null,
       cell: ({
         row
-      }) => /* @__PURE__ */ React7__default.default.createElement(SelectionCell, {
+      }) => /* @__PURE__ */ React21__default.default.createElement(SelectionCell, {
         row,
-        onToggleRow
+        onToggleRow: onToggleRowRef.current
       }),
       size: 50,
       minSize: 50,
@@ -447,7 +3429,7 @@ var useSelectionColumn = ({
       enablePinning: false
     };
     return colDef;
-  }, [selectionMode, isAllSelected, hasSelection, onToggleAll, onToggleRow]);
+  }, [selectionMode]);
   return selectionColumn;
 };
 var useTableSorting = ({
@@ -455,10 +3437,10 @@ var useTableSorting = ({
   defaultOrderBy,
   onOrderByChanged
 }) => {
-  const [internalSorting, setInternalSorting] = React7.useState(() => defaultOrderBy ? convertOrderByToSortingState(defaultOrderBy) : []);
+  const [internalSorting, setInternalSorting] = React21.useState(() => defaultOrderBy ? convertOrderByToSortingState(defaultOrderBy) : []);
   const isControlled = orderBy !== void 0;
-  const sortingState = React7.useMemo(() => orderBy ? convertOrderByToSortingState(orderBy) : internalSorting, [orderBy, internalSorting]);
-  const onSortingChange = React7.useCallback((updater) => {
+  const sortingState = React21.useMemo(() => orderBy ? convertOrderByToSortingState(orderBy) : internalSorting, [orderBy, internalSorting]);
+  const onSortingChange = React21.useCallback((updater) => {
     const newSorting = typeof updater === "function" ? updater(sortingState) : updater;
     if (!isControlled) {
       setInternalSorting(newSorting);
@@ -492,6 +3474,29 @@ function convertSortingStateToOrderBy(sorting) {
   }));
 }
 
+// src/base-components/action-button/ActionButton.module.css
+var ActionButton_default = {};
+
+// src/base-components/action-button/ActionButton.tsx
+function _extends8() {
+  return _extends8 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends8.apply(null, arguments);
+}
+function ActionButton({
+  variant = "secondary",
+  className,
+  ...rest
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(button.Button, _extends8({
+    className: classnames7__default.default(ActionButton_default.button, variant === "primary" ? ActionButton_default.primaryButton : ActionButton_default.secondaryButton, className)
+  }, rest));
+}
+
 // src/object-table/LoadingCell.module.css
 var LoadingCell_default = {};
 
@@ -502,13 +3507,13 @@ var TableCell_default = {};
 function LoadingCell({
   width
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement("td", {
+  return /* @__PURE__ */ React21__default.default.createElement("td", {
     className: TableCell_default.osdkTableCell,
     style: {
       width
     }
-  }, /* @__PURE__ */ React7__default.default.createElement("div", {
-    className: classNames2__default.default(LoadingCell_default.osdkLoadingCell, LoadingCell_default.osdkCellSkeleton)
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(LoadingCell_default.osdkLoadingCell, LoadingCell_default.osdkCellSkeleton)
   }));
 }
 
@@ -523,17 +3528,17 @@ function LoadingRow({
   rowHeight = 40,
   columnWidth = 80
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement("tr", {
+  return /* @__PURE__ */ React21__default.default.createElement("tr", {
     className: TableRow_default.osdkTableRow,
     style: {
       height: `${rowHeight}px`,
       transform: `translateY(${translateY}px)`
     }
-  }, /* @__PURE__ */ React7__default.default.createElement(React7__default.default.Fragment, null, Array.from({
+  }, /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, Array.from({
     length: columnCount
   }).map((_, index) => {
     const width = headers.length > index ? headers[index].getSize() : columnWidth;
-    return /* @__PURE__ */ React7__default.default.createElement(LoadingCell, {
+    return /* @__PURE__ */ React21__default.default.createElement(LoadingCell, {
       key: `loading-cell-${index}`,
       width
     });
@@ -543,6 +3548,597 @@ function LoadingRow({
 // src/object-table/TableBody.module.css
 var TableBody_default = {};
 
+// src/base-components/dialog/Dialog.module.css
+var Dialog_default = {};
+
+// src/base-components/dialog/Dialog.tsx
+function Dialog({
+  isOpen,
+  onOpenChange,
+  title,
+  children,
+  footer,
+  className
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Root, {
+    open: isOpen,
+    onOpenChange
+  }, /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Portal, null, /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Backdrop, {
+    className: Dialog_default.backdrop
+  }), /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Popup, {
+    className: classnames7__default.default(Dialog_default.popup, className)
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: Dialog_default.header
+  }, /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Title, {
+    className: Dialog_default.title
+  }, title), /* @__PURE__ */ React21__default.default.createElement(dialog.Dialog.Close, {
+    className: Dialog_default.closeButton,
+    "aria-label": "Close dialog"
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Cross, {
+    className: Dialog_default.closeIcon
+  }))), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: Dialog_default.body
+  }, children), footer != null && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: Dialog_default.footer
+  }, footer))));
+}
+
+// src/base-components/draggable-list/DraggableList.module.css
+var DraggableList_default = {};
+
+// src/base-components/draggable-list/DraggableList.tsx
+function _extends9() {
+  return _extends9 = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends9.apply(null, arguments);
+}
+function DraggableListItem({
+  item,
+  onRemove,
+  removeIconVariant = "trash",
+  renderContent
+}) {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging
+  } = sortable.useSortable({
+    id: item.id
+  });
+  const style = {
+    transform: utilities.CSS.Transform.toString(transform),
+    transition
+  };
+  const handleRemove = React21.useCallback(() => {
+    onRemove?.(item.id);
+  }, [item.id, onRemove]);
+  const RemoveIcon = removeIconVariant === "trash" ? icons.Trash : icons.SmallCross;
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    ref: setNodeRef,
+    style,
+    className: DraggableList_default.draggableItem,
+    "data-dragging": isDragging
+  }, /* @__PURE__ */ React21__default.default.createElement("div", _extends9({
+    className: DraggableList_default.dragHandle,
+    "aria-label": `Reorder ${item.label}`
+  }, attributes, listeners), /* @__PURE__ */ React21__default.default.createElement(icons.DragHandleVertical, {
+    className: DraggableList_default.icon
+  })), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: DraggableList_default.itemContent
+  }, renderContent ? renderContent(item) : item.label), onRemove && /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    className: DraggableList_default.removeButton,
+    onClick: handleRemove,
+    "aria-label": `Remove ${item.label}`
+  }, /* @__PURE__ */ React21__default.default.createElement(RemoveIcon, {
+    className: DraggableList_default.icon
+  })));
+}
+function DraggableList({
+  items,
+  onReorder,
+  onRemove,
+  removeIconVariant = "cross",
+  renderContent,
+  emptyMessage,
+  className
+}) {
+  const itemIds = React21.useMemo(() => items.map((item) => item.id), [items]);
+  const sensors = core.useSensors(core.useSensor(core.PointerSensor, {
+    activationConstraint: {
+      distance: 5
+    }
+  }), core.useSensor(core.KeyboardSensor, {
+    coordinateGetter: sortable.sortableKeyboardCoordinates
+  }));
+  const handleDragEnd = React21.useCallback((event) => {
+    const {
+      active,
+      over
+    } = event;
+    if (over && active.id !== over.id) {
+      const oldIndex = items.findIndex((item) => item.id === active.id);
+      const newIndex = items.findIndex((item) => item.id === over.id);
+      onReorder(oldIndex, newIndex);
+    }
+  }, [items, onReorder]);
+  const containerRef = React21.useRef(null);
+  useKeyboardEvents(containerRef);
+  const DndContext = core.DndContext;
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    ref: containerRef,
+    className: classnames7__default.default(DraggableList_default.draggableListContainer, className)
+  }, /* @__PURE__ */ React21__default.default.createElement(DndContext, {
+    sensors,
+    collisionDetection: core.closestCenter,
+    onDragEnd: handleDragEnd
+  }, /* @__PURE__ */ React21__default.default.createElement(sortable.SortableContext, {
+    items: itemIds,
+    strategy: sortable.verticalListSortingStrategy
+  }, items.map((item) => /* @__PURE__ */ React21__default.default.createElement(DraggableListItem, {
+    key: item.id,
+    item,
+    onRemove,
+    removeIconVariant,
+    renderContent
+  })))), items.length === 0 && emptyMessage && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: DraggableList_default.emptyState
+  }, emptyMessage));
+}
+var useKeyboardEvents = (containerRef) => {
+  React21.useEffect(() => {
+    const el = containerRef.current;
+    if (el == null) {
+      return;
+    }
+    const ARROW_KEYS = /* @__PURE__ */ new Set(["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"]);
+    function handleCapture(event) {
+      if (!ARROW_KEYS.has(event.key)) {
+        return;
+      }
+      if (el.querySelector('[data-dragging="true"]') == null) {
+        return;
+      }
+      event.stopPropagation();
+      document.dispatchEvent(new KeyboardEvent("keydown", {
+        key: event.key,
+        code: event.code,
+        bubbles: true
+      }));
+    }
+    el.addEventListener("keydown", handleCapture, true);
+    return () => el.removeEventListener("keydown", handleCapture, true);
+  }, [containerRef]);
+};
+
+// src/base-components/search-bar/SearchBar.module.css
+var SearchBar_default = {};
+
+// src/base-components/search-bar/SearchBar.tsx
+function SearchBar({
+  value,
+  onChange,
+  placeholder = "Search",
+  "aria-label": ariaLabel,
+  className,
+  onKeyDown
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(SearchBar_default.searchBar, className)
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Search, {
+    className: SearchBar_default.searchIcon
+  }), /* @__PURE__ */ React21__default.default.createElement(input.Input, {
+    type: "text",
+    placeholder,
+    "aria-label": ariaLabel ?? placeholder,
+    value,
+    onChange,
+    className: SearchBar_default.searchInput,
+    onKeyDown
+  }));
+}
+
+// src/object-table/ColumnConfigDialog.module.css
+var ColumnConfigDialog_default = {};
+
+// src/object-table/ColumnConfigDialog.tsx
+function ColumnConfigDialog({
+  isOpen,
+  onClose,
+  columnOptions,
+  currentVisibility,
+  currentColumnOrder,
+  onApply,
+  isValidConfig
+}) {
+  const [visibleColumns, setVisibleColumns] = React21.useState([]);
+  const [searchQuery, setSearchQuery] = React21.useState("");
+  const allColumns = React21.useMemo(() => {
+    return columnOptions.map((opt) => {
+      const isVisible = currentVisibility ? currentVisibility[opt.id] : false;
+      return {
+        id: opt.id,
+        label: opt.name,
+        isVisible
+      };
+    });
+  }, [columnOptions, currentVisibility]);
+  React21.useEffect(() => {
+    if (isOpen) {
+      const visibleCols = allColumns.filter((col) => col.isVisible);
+      if (!!currentColumnOrder?.length) {
+        visibleCols.sort((a, b) => {
+          const indexA = currentColumnOrder.indexOf(a.id);
+          const indexB = currentColumnOrder.indexOf(b.id);
+          const orderA = indexA === -1 ? Infinity : indexA;
+          const orderB = indexB === -1 ? Infinity : indexB;
+          return orderA - orderB;
+        });
+      }
+      setVisibleColumns(visibleCols);
+      setSearchQuery("");
+    }
+  }, [isOpen, allColumns, currentColumnOrder]);
+  const handleApply = React21.useCallback(() => {
+    onApply(getColumnConfig(allColumns, visibleColumns));
+    onClose();
+  }, [allColumns, visibleColumns, onApply, onClose]);
+  const isValid = isValidConfig ? isValidConfig(getColumnConfig(allColumns, visibleColumns)) : true;
+  const isApplyDisabled = visibleColumns.length === 0 || !isValid;
+  const handleReorderColumns = React21.useCallback((fromIndex, toIndex) => {
+    setVisibleColumns((items) => sortable.arrayMove(items, fromIndex, toIndex));
+  }, []);
+  const handleRemoveColumn = React21.useCallback((columnId) => {
+    setVisibleColumns((prev) => prev.filter((col) => col.id !== columnId));
+  }, []);
+  const handleToggleColumn = React21.useCallback((column) => {
+    setVisibleColumns((prev) => {
+      const isCurrentlyVisible = prev.some((col) => col.id === column.id);
+      if (isCurrentlyVisible) {
+        return prev.filter((col) => col.id !== column.id);
+      } else {
+        return [...prev, column];
+      }
+    });
+  }, []);
+  const handleSearchChange = React21.useCallback((event) => {
+    setSearchQuery(event.target.value);
+  }, []);
+  const handleSelectAll = React21.useCallback((columns) => {
+    setVisibleColumns((prev) => {
+      const allSelected = columns.every((col) => prev.some((v) => v.id === col.id));
+      if (allSelected) {
+        return prev.filter((v) => !columns.some((col) => col.id === v.id));
+      } else {
+        const newColumns = columns.filter((col) => !prev.some((v) => v.id === col.id));
+        return [...prev, ...newColumns];
+      }
+    });
+  }, []);
+  const filteredAvailableColumns = React21.useMemo(() => {
+    const query = searchQuery.toLowerCase().trim();
+    if (!query) {
+      return allColumns;
+    }
+    return allColumns.filter((col) => (col.label?.toLowerCase().includes(query) ?? false) || col.id.toLowerCase().includes(query));
+  }, [allColumns, searchQuery]);
+  const footer = React21.useMemo(() => /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(ActionButton, {
+    onClick: onClose
+  }, "Cancel"), /* @__PURE__ */ React21__default.default.createElement(ActionButton, {
+    variant: "primary",
+    onClick: handleApply,
+    disabled: isApplyDisabled
+  }, "Apply")), [onClose, handleApply, isApplyDisabled]);
+  return /* @__PURE__ */ React21__default.default.createElement(Dialog, {
+    isOpen,
+    onOpenChange: onClose,
+    title: DialogTitle,
+    footer,
+    className: ColumnConfigDialog_default.columnConfigDialog
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.dialogLayout
+  }, /* @__PURE__ */ React21__default.default.createElement(VisibleColumnsList, {
+    columns: visibleColumns,
+    onReorder: handleReorderColumns,
+    onRemove: handleRemoveColumn
+  }), /* @__PURE__ */ React21__default.default.createElement(AvailableColumnsList, {
+    visibleColumns,
+    searchQuery,
+    onSearchChange: handleSearchChange,
+    onToggleColumn: handleToggleColumn,
+    onSelectAll: handleSelectAll,
+    filteredColumns: filteredAvailableColumns
+  })));
+}
+var DialogTitle = /* @__PURE__ */ React21__default.default.createElement("div", {
+  className: ColumnConfigDialog_default.title
+}, /* @__PURE__ */ React21__default.default.createElement(icons.Cog, null), "Configure Table Columns");
+var getColumnConfig = (allColumns, visibleColumns) => {
+  const hiddenColumns = allColumns.filter((col) => !visibleColumns.some((v) => v.id === col.id));
+  return [...visibleColumns.map((col) => ({
+    columnId: col.id,
+    isVisible: true
+  })), ...hiddenColumns.map((col) => ({
+    columnId: col.id,
+    isVisible: false
+  }))];
+};
+function VisibleColumnsList({
+  columns,
+  onReorder,
+  onRemove
+}) {
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.visibleColumnsContainer
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.sectionHeader
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.sectionTitle
+  }, /* @__PURE__ */ React21__default.default.createElement("span", null, "Visible Columns"), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: ColumnConfigDialog_default.countTag
+  }, columns.length)), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.sectionHint
+  }, "Drag to reorder")), /* @__PURE__ */ React21__default.default.createElement(DraggableList, {
+    items: columns,
+    onReorder,
+    onRemove,
+    removeIconVariant: "trash",
+    emptyMessage: "No visible columns",
+    className: ColumnConfigDialog_default.columnList
+  }));
+}
+function AvailableColumnsList({
+  visibleColumns,
+  searchQuery,
+  onSearchChange,
+  onToggleColumn,
+  onSelectAll,
+  filteredColumns
+}) {
+  const selectedCount = visibleColumns.length;
+  const totalCount = filteredColumns.length;
+  const allFilteredSelected = filteredColumns.every((col) => visibleColumns.some((v) => v.id === col.id));
+  const someFilteredSelected = filteredColumns.some((col) => visibleColumns.some((v) => v.id === col.id));
+  const handleSelectAllClick = React21.useCallback(() => {
+    onSelectAll(filteredColumns);
+  }, [filteredColumns, onSelectAll]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.availableColumnsContainer
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(ColumnConfigDialog_default.sectionHeader, ColumnConfigDialog_default.sectionTitle)
+  }, "Add or Remove Columns"), /* @__PURE__ */ React21__default.default.createElement(SearchBar, {
+    value: searchQuery,
+    onChange: onSearchChange,
+    placeholder: "Search...",
+    "aria-label": "Search available columns",
+    className: ColumnConfigDialog_default.searchContainer
+  }), /* @__PURE__ */ React21__default.default.createElement(collapsible.Collapsible.Root, {
+    defaultOpen: true,
+    className: ColumnConfigDialog_default.propertiesList
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.categoryHeader
+  }, /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
+    checked: allFilteredSelected,
+    indeterminate: someFilteredSelected && !allFilteredSelected,
+    onCheckedChange: handleSelectAllClick,
+    className: ColumnConfigDialog_default.checkbox
+  }), /* @__PURE__ */ React21__default.default.createElement(collapsible.Collapsible.Trigger, {
+    className: ColumnConfigDialog_default.categoryTrigger
+  }, /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: ColumnConfigDialog_default.categoryTitle
+  }, "All Columns"), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: ColumnConfigDialog_default.categoryCount
+  }, selectedCount, "/", totalCount), /* @__PURE__ */ React21__default.default.createElement(icons.CaretDown, {
+    className: ColumnConfigDialog_default.caretIcon
+  }))), /* @__PURE__ */ React21__default.default.createElement(collapsible.Collapsible.Panel, {
+    className: ColumnConfigDialog_default.propertyList
+  }, filteredColumns.length === 0 ? /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.emptyState
+  }, "No matching columns found") : filteredColumns.map((column) => /* @__PURE__ */ React21__default.default.createElement(PropertyItem, {
+    key: column.id,
+    column,
+    isSelected: visibleColumns.some((v) => v.id === column.id),
+    onToggle: onToggleColumn
+  })))));
+}
+function PropertyItem({
+  column,
+  isSelected,
+  onToggle,
+  showInfoIcon = false
+}) {
+  const handleClick = React21.useCallback(() => {
+    onToggle(column);
+  }, [onToggle, column]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: ColumnConfigDialog_default.propertyItem
+  }, /* @__PURE__ */ React21__default.default.createElement(Checkbox, {
+    checked: isSelected,
+    onCheckedChange: handleClick,
+    className: ColumnConfigDialog_default.checkbox
+  }), /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+    onClick: handleClick,
+    className: ColumnConfigDialog_default.propertyName
+  }, column.label), showInfoIcon && /* @__PURE__ */ React21__default.default.createElement(icons.SmallInfoSign, {
+    className: ColumnConfigDialog_default.infoIcon
+  }));
+}
+
+// src/object-table/MultiColumnSortDialog.module.css
+var MultiColumnSortDialog_default = {};
+function SortableItemsList({
+  items,
+  onReorder,
+  onRemove,
+  className
+}) {
+  const renderContent = React21.useCallback((item) => item.content, []);
+  return /* @__PURE__ */ React21__default.default.createElement(DraggableList, {
+    items,
+    onReorder,
+    onRemove,
+    removeIconVariant: "cross",
+    renderContent,
+    className
+  });
+}
+
+// src/object-table/MultiColumnSortDialog.tsx
+function MultiColumnSortDialog({
+  isOpen,
+  onClose,
+  onApply,
+  currentSorting,
+  columnOptions
+}) {
+  const [selectedSortColumns, setSelectedSortColumns] = React21.useState([]);
+  const [menuSearchQuery, setMenuSearchQuery] = React21.useState("");
+  React21.useEffect(() => {
+    if (isOpen) {
+      const selectedColumns = [];
+      for (const sort of currentSorting) {
+        const column = columnOptions.find((col) => col.id === sort.id);
+        if (column) {
+          selectedColumns.push({
+            ...column,
+            direction: sort.desc ? "desc" : "asc"
+          });
+        }
+      }
+      setSelectedSortColumns(selectedColumns);
+    }
+  }, [isOpen, currentSorting, columnOptions]);
+  const handleAddColumn = React21.useCallback((column) => {
+    setSelectedSortColumns((prev) => [...prev, {
+      ...column,
+      direction: "asc"
+    }]);
+  }, []);
+  const handleRemoveSortColumn = React21.useCallback((id) => {
+    setSelectedSortColumns((prev) => prev.filter((item) => item.id !== id));
+  }, []);
+  const handleReorderSortColumns = React21.useCallback((fromIndex, toIndex) => {
+    setSelectedSortColumns((items) => sortable.arrayMove(items, fromIndex, toIndex));
+  }, []);
+  const handleToggleSortDirection = React21.useCallback((id) => {
+    setSelectedSortColumns((prev) => prev.map((item) => item.id === id ? {
+      ...item,
+      direction: item.direction === "asc" ? "desc" : "asc"
+    } : item));
+  }, []);
+  const handleApply = React21.useCallback(() => {
+    const sortingState = selectedSortColumns.map((col) => ({
+      id: col.id,
+      desc: col.direction === "desc"
+    }));
+    onApply(sortingState);
+    onClose();
+  }, [selectedSortColumns, onApply, onClose]);
+  const availableColumns = React21.useMemo(() => columnOptions.filter((col) => col.canSort && !selectedSortColumns.some((selected) => selected.id === col.id)), [columnOptions, selectedSortColumns]);
+  const filteredAvailableColumns = React21.useMemo(() => {
+    const query = menuSearchQuery.toLowerCase().trim();
+    if (!query) {
+      return availableColumns;
+    }
+    return availableColumns.filter((col) => col.name.toLowerCase().includes(query));
+  }, [availableColumns, menuSearchQuery]);
+  const handleMenuSearchChange = React21.useCallback((event) => {
+    setMenuSearchQuery(event.target.value);
+  }, []);
+  const handleMenuOpenChange = React21.useCallback((open) => {
+    if (open) {
+      setMenuSearchQuery("");
+    }
+  }, []);
+  const sortableItems = React21.useMemo(() => {
+    return selectedSortColumns.map((item) => ({
+      id: item.id,
+      label: item.name,
+      content: /* @__PURE__ */ React21__default.default.createElement("div", {
+        className: MultiColumnSortDialog_default.sortColumnItem
+      }, /* @__PURE__ */ React21__default.default.createElement("span", {
+        className: classnames7__default.default(MultiColumnSortDialog_default.sortColumnName, MultiColumnSortDialog_default.truncate)
+      }, item.name), /* @__PURE__ */ React21__default.default.createElement(button.Button, {
+        className: MultiColumnSortDialog_default.sortDirectionButton,
+        onClick: () => handleToggleSortDirection(item.id),
+        "aria-label": `Toggle sort direction for ${item.name}`
+      }, item.direction === "asc" ? /* @__PURE__ */ React21__default.default.createElement(icons.SortAlphabetical, {
+        className: MultiColumnSortDialog_default.sortIcon
+      }) : /* @__PURE__ */ React21__default.default.createElement(icons.SortAlphabeticalDesc, {
+        className: MultiColumnSortDialog_default.sortIcon
+      })))
+    }));
+  }, [selectedSortColumns, handleToggleSortDirection]);
+  const footer = React21.useMemo(() => /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(ActionButton, {
+    onClick: onClose
+  }, "Cancel"), /* @__PURE__ */ React21__default.default.createElement(ActionButton, {
+    variant: "primary",
+    onClick: handleApply
+  }, "Apply")), [handleApply, onClose]);
+  return /* @__PURE__ */ React21__default.default.createElement(Dialog, {
+    isOpen,
+    onOpenChange: onClose,
+    title: DialogTitle2,
+    footer
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: MultiColumnSortDialog_default.sortColumnsList
+  }, /* @__PURE__ */ React21__default.default.createElement(SortableItemsList, {
+    items: sortableItems,
+    onReorder: handleReorderSortColumns,
+    onRemove: handleRemoveSortColumn,
+    className: MultiColumnSortDialog_default.sortableList
+  }), /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Root, {
+    onOpenChange: handleMenuOpenChange
+  }, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Trigger, {
+    className: MultiColumnSortDialog_default.addColumnButton,
+    disabled: availableColumns.length === 0,
+    "aria-label": "Add column to sort"
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.Add, {
+    className: MultiColumnSortDialog_default.addIcon
+  }), /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: MultiColumnSortDialog_default.addColumnText
+  }, "Add Column to Sort"), /* @__PURE__ */ React21__default.default.createElement(icons.CaretDown, {
+    color: "currentColor"
+  })), /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Portal, null, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Positioner, {
+    className: MultiColumnSortDialog_default.menuPositioner,
+    sideOffset: 4
+  }, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Popup, {
+    className: MultiColumnSortDialog_default.dropdownMenu
+  }, /* @__PURE__ */ React21__default.default.createElement(SearchBar, {
+    value: menuSearchQuery,
+    onChange: handleMenuSearchChange,
+    placeholder: "Search columns",
+    "aria-label": "Search columns to sort",
+    className: MultiColumnSortDialog_default.menuSearchContainer,
+    onKeyDown: (e) => e.stopPropagation()
+  }), filteredAvailableColumns.map((column) => /* @__PURE__ */ React21__default.default.createElement(AvailableColumnMenuItem, {
+    key: column.id,
+    column,
+    onAddColumn: handleAddColumn
+  })), filteredAvailableColumns.length === 0 && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: MultiColumnSortDialog_default.menuEmptyState
+  }, "No matching columns")))))));
+}
+var DialogTitle2 = /* @__PURE__ */ React21__default.default.createElement("div", {
+  className: MultiColumnSortDialog_default.title
+}, /* @__PURE__ */ React21__default.default.createElement(icons.Cog, null), "Sort on Multiple Columns");
+function AvailableColumnMenuItem({
+  column,
+  onAddColumn
+}) {
+  const onClick = React21.useCallback(() => onAddColumn(column), [onAddColumn, column]);
+  return /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Item, {
+    className: classnames7__default.default(MultiColumnSortDialog_default.dropdownItem, MultiColumnSortDialog_default.truncate),
+    onClick
+  }, column.name);
+}
+
 // src/object-table/TableHeader.module.css
 var TableHeader_default = {};
 
@@ -553,7 +4149,7 @@ var TableHeaderContent_default = {};
 function TableHeaderContent({
   header
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement("div", {
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
     className: TableHeaderContent_default.osdkHeaderContent
   }, reactTable.flexRender(header.column.columnDef.header, header.getContext()));
 }
@@ -568,24 +4164,38 @@ function HeaderMenuItem({
   label,
   active = false
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Item, {
+  return /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Item, {
     closeOnClick: true,
-    className: classNames2__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderMenuItem, active && TableHeaderWithPopover_default.osdkHeaderActiveMenuItem),
+    className: classnames7__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderMenuItem, active && TableHeaderWithPopover_default.osdkHeaderActiveMenuItem),
     onClick
-  }, /* @__PURE__ */ React7__default.default.createElement(Icon, {
+  }, /* @__PURE__ */ React21__default.default.createElement(Icon, {
     className: TableHeaderWithPopover_default.osdkHeaderIcon,
     color: "currentColor"
-  }), /* @__PURE__ */ React7__default.default.createElement("span", null, label));
+  }), /* @__PURE__ */ React21__default.default.createElement("span", null, label));
 }
 function TableHeaderWithPopover({
   header,
+  table,
   isColumnPinned,
-  setColumnPinning,
-  onSortChange,
-  onResetSize
+  onResetSize,
+  columnOptions,
+  featureFlags,
+  onOpenColumnConfig,
+  onOpenMultiSort
 }) {
-  const [isOpen, setIsOpen] = React7.useState(false);
-  const handlePinLeft = React7.useCallback(() => {
+  const {
+    showSortingItems = false,
+    showPinningItems = false,
+    showResizeItem = false,
+    showConfigItem = false
+  } = featureFlags ?? {};
+  const {
+    setColumnPinning,
+    setSorting
+  } = table;
+  const currentSorting = table.getState().sorting;
+  const [isOpen, setIsOpen] = React21.useState(false);
+  const handlePinLeft = React21.useCallback(() => {
     setColumnPinning((prev) => {
       return {
         left: [...prev.left || [], header.column.id],
@@ -593,7 +4203,7 @@ function TableHeaderWithPopover({
       };
     });
   }, [header.column.id, setColumnPinning]);
-  const handleUnpin = React7.useCallback(() => {
+  const handleUnpin = React21.useCallback(() => {
     setColumnPinning((prev) => {
       return {
         left: prev.left?.filter((id) => id !== header.column.id) || [],
@@ -601,98 +4211,116 @@ function TableHeaderWithPopover({
       };
     });
   }, [header.column.id, setColumnPinning]);
-  const handleSortAscending = React7.useCallback(() => {
+  const handleSortAscending = React21.useCallback(() => {
     header.column.toggleSorting(false);
-    onSortChange?.([{
+    setSorting?.([{
       id: header.column.id,
       desc: false
     }]);
-  }, [header.column, onSortChange]);
-  const handleSortDescending = React7.useCallback(() => {
+  }, [header.column, setSorting]);
+  const handleSortDescending = React21.useCallback(() => {
     header.column.toggleSorting(true);
-    onSortChange?.([{
+    setSorting?.([{
       id: header.column.id,
       desc: true
     }]);
-  }, [header.column, onSortChange]);
-  const handleClearAllSorts = React7.useCallback(() => {
+  }, [header.column, setSorting]);
+  const handleClearAllSorts = React21.useCallback(() => {
     header.column.clearSorting();
-    onSortChange?.([]);
-  }, [header.column, onSortChange]);
-  const handleResetSize = React7.useCallback(() => {
+    setSorting?.([]);
+  }, [header.column, setSorting]);
+  const handleResetSize = React21.useCallback(() => {
     header.column.resetSize();
     if (onResetSize) {
       onResetSize();
     }
   }, [header.column, onResetSize]);
-  const handleInteraction = React7.useCallback((e) => {
+  const handleInteraction = React21.useCallback((e) => {
     e.preventDefault();
     setIsOpen((prev) => !prev);
   }, []);
+  const handleOpenColumnConfig = React21.useCallback(() => {
+    onOpenColumnConfig?.();
+    setIsOpen(false);
+  }, [onOpenColumnConfig]);
+  const handleOpenMultiSort = React21.useCallback(() => {
+    onOpenMultiSort?.();
+    setIsOpen(false);
+  }, [onOpenMultiSort]);
   const isSorted = header.column.getIsSorted();
   const isSortable = header.column.getCanSort();
-  return /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Root, {
+  const sortIndex = currentSorting?.findIndex((s) => s.id === header.column.id) ?? -1;
+  const hasAnyMenuItems = showPinningItems || showSortingItems && isSortable || showResizeItem || showConfigItem;
+  return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Root, {
     open: isOpen,
     onOpenChange: setIsOpen
-  }, /* @__PURE__ */ React7__default.default.createElement("div", {
-    className: classNames2__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContainer),
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContainer),
     onContextMenu: handleInteraction
-  }, /* @__PURE__ */ React7__default.default.createElement("div", {
-    className: classNames2__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContentLeft)
-  }, isColumnPinned && /* @__PURE__ */ React7__default.default.createElement(icons.Pin, {
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContentLeft)
+  }, isColumnPinned && /* @__PURE__ */ React21__default.default.createElement(icons.Pin, {
     className: TableHeaderWithPopover_default.osdkHeaderIcon,
     color: "currentColor"
-  }), /* @__PURE__ */ React7__default.default.createElement(TableHeaderContent, {
+  }), /* @__PURE__ */ React21__default.default.createElement(TableHeaderContent, {
     header
-  })), /* @__PURE__ */ React7__default.default.createElement("div", {
-    className: classNames2__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContentRight)
-  }, isSorted && /* @__PURE__ */ React7__default.default.createElement("div", {
+  })), /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkContentGap, TableHeaderWithPopover_default.osdkHeaderContentRight)
+  }, isSorted && /* @__PURE__ */ React21__default.default.createElement("div", {
     className: TableHeaderWithPopover_default.osdkCenterContainer
-  }, isSorted === "asc" ? /* @__PURE__ */ React7__default.default.createElement(icons.SortAlphabetical, {
-    className: TableHeaderWithPopover_default.osdkHeaderIcon,
-    color: "currentColor"
-  }) : /* @__PURE__ */ React7__default.default.createElement(icons.SortAlphabeticalDesc, {
-    className: TableHeaderWithPopover_default.osdkHeaderIcon,
-    color: "currentColor"
-  })), /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Trigger, {
+  }, isSorted === "asc" ? /* @__PURE__ */ React21__default.default.createElement(icons.SortAlphabetical, {
+    className: TableHeaderWithPopover_default.osdkHeaderIcon
+  }) : /* @__PURE__ */ React21__default.default.createElement(icons.SortAlphabeticalDesc, {
+    className: TableHeaderWithPopover_default.osdkHeaderIcon
+  }), currentSorting.length > 1 && sortIndex >= 0 && /* @__PURE__ */ React21__default.default.createElement("span", {
+    className: TableHeaderWithPopover_default.sortIndex
+  }, sortIndex + 1)), hasAnyMenuItems && /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Trigger, {
     "aria-label": `Open header menu for column with id=${header.column.id}`,
-    className: classNames2__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkHeaderPopoverTrigger)
-  }, /* @__PURE__ */ React7__default.default.createElement(icons.ChevronDown, {
+    className: classnames7__default.default(TableHeaderWithPopover_default.osdkCenterContainer, TableHeaderWithPopover_default.osdkHeaderPopoverTrigger)
+  }, /* @__PURE__ */ React21__default.default.createElement(icons.ChevronDown, {
     className: TableHeaderWithPopover_default.osdkHeaderIcon
-  }))), /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Portal, {
+  }))), /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Portal, {
     container: document.body
-  }, /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Positioner, {
+  }, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Positioner, {
     sideOffset: 4
-  }, /* @__PURE__ */ React7__default.default.createElement(menu.Menu.Popup, {
+  }, /* @__PURE__ */ React21__default.default.createElement(menu.Menu.Popup, {
     className: TableHeaderWithPopover_default.osdkHeaderPopup
-  }, !isColumnPinned && /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }, showPinningItems && !isColumnPinned && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handlePinLeft,
     icon: icons.Pin,
     label: "Pin column"
-  }), isColumnPinned && /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }), showPinningItems && isColumnPinned && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handleUnpin,
     icon: icons.Unpin,
     label: "Unpin Column",
     active: true
-  }), isSortable && /* @__PURE__ */ React7__default.default.createElement(React7__default.default.Fragment, null, /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }), showSortingItems && isSortable && /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handleSortAscending,
     icon: icons.SortAlphabetical,
     label: "Sort ascending",
     active: isSorted === "asc"
-  }), /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }), /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handleSortDescending,
     icon: icons.SortAlphabeticalDesc,
     label: "Sort descending",
     active: isSorted === "desc"
-  })), !!isSorted && /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }), columnOptions?.some((col) => col.canSort) && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
+    onClick: handleOpenMultiSort,
+    icon: icons.Sort,
+    label: "Sort on multiple columns"
+  })), showSortingItems && !!currentSorting?.length && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handleClearAllSorts,
     icon: icons.Remove,
     label: "Clear all sorts"
-  }), /* @__PURE__ */ React7__default.default.createElement(HeaderMenuItem, {
+  }), showResizeItem && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
     onClick: handleResetSize,
     icon: icons.VerticalDistribution,
     label: "Reset Column Size"
-  }))))));
+  }), showConfigItem && /* @__PURE__ */ React21__default.default.createElement(HeaderMenuItem, {
+    onClick: handleOpenColumnConfig,
+    icon: icons.Settings,
+    label: "Configure Columns"
+  })))))));
 }
 
 // src/object-table/utils/getColumnPinningStyles.ts
@@ -708,14 +4336,80 @@ function getColumnPinningStyles(column) {
 }
 
 // src/object-table/TableHeader.tsx
+var getHeaderName = (column, allHeaders) => {
+  const {
+    id,
+    columnDef
+  } = column;
+  const header = allHeaders.find((header2) => header2.id === id);
+  const headerDef = columnDef.header;
+  if (headerDef) {
+    if (typeof headerDef === "string") {
+      return headerDef;
+    }
+    if (header) {
+      const displayedHeader = headerDef(header.getContext());
+      if (typeof displayedHeader === "string") return displayedHeader;
+    }
+  }
+  const {
+    meta
+  } = columnDef;
+  return meta?.columnName ?? id;
+};
 function TableHeader({
-  table
+  table,
+  headerMenuFeatureFlags
 }) {
+  const {
+    setColumnOrder,
+    setColumnVisibility,
+    setSorting
+  } = table;
+  const currentSorting = table.getState().sorting;
+  const currentVisibility = table.getState().columnVisibility;
+  const currentColumnOrder = table.getState().columnOrder;
   const isResizing = !!table.getState().columnSizingInfo?.isResizingColumn;
-  return /* @__PURE__ */ React7__default.default.createElement("thead", {
+  const [configDialogOpen, setConfigDialogOpen] = React21.useState(false);
+  const [multiSortDialogOpen, setMultiSortDialogOpen] = React21.useState(false);
+  const handleOpenColumnConfig = React21.useCallback(() => {
+    setConfigDialogOpen(true);
+  }, []);
+  const handleCloseColumnConfig = React21.useCallback(() => {
+    setConfigDialogOpen(false);
+  }, []);
+  const handleOpenMultiSort = React21.useCallback(() => {
+    setMultiSortDialogOpen(true);
+  }, []);
+  const handleCloseMultiSort = React21.useCallback(() => {
+    setMultiSortDialogOpen(false);
+  }, []);
+  const handleApplyMultiSort = React21.useCallback((sortColumns) => {
+    setMultiSortDialogOpen(false);
+    setSorting?.(sortColumns);
+  }, [setSorting]);
+  const handleApplyColumnConfig = React21.useCallback((updates) => {
+    const newVisibilityState = {};
+    for (const update of updates) {
+      newVisibilityState[update.columnId] = update.isVisible;
+    }
+    setColumnOrder(updates.map((col) => col.columnId));
+    setColumnVisibility(newVisibilityState);
+  }, [setColumnOrder, setColumnVisibility]);
+  const columnOptions = React21.useMemo(() => {
+    const allHeaders = table.getHeaderGroups().flatMap((headerGroup) => headerGroup.headers);
+    return table.getAllColumns().filter((column) => column.id !== SELECTION_COLUMN_ID).map((column) => {
+      return {
+        id: column.id,
+        name: getHeaderName(column, allHeaders),
+        canSort: column.getCanSort()
+      };
+    });
+  }, [table]);
+  return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement("thead", {
     className: TableHeader_default.osdkTableHeader,
     "data-resizing": isResizing
-  }, table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ React7__default.default.createElement("tr", {
+  }, table.getHeaderGroups().map((headerGroup) => /* @__PURE__ */ React21__default.default.createElement("tr", {
     key: headerGroup.id,
     className: TableHeader_default.osdkTableHeaderRow
   }, headerGroup.headers.map((header) => {
@@ -724,24 +4418,41 @@ function TableHeader({
     } = getColumnPinningStyles(header.column);
     const isColumnPinned = header.column.getIsPinned();
     const isSelectColumn = header.id === SELECTION_COLUMN_ID;
-    return /* @__PURE__ */ React7__default.default.createElement("th", {
+    return /* @__PURE__ */ React21__default.default.createElement("th", {
       key: header.id,
       "data-pinned": header.column.getIsPinned(),
       className: TableHeader_default.osdkTableHeaderCell,
       style: columnStyles
-    }, header.isPlaceholder ? null : isSelectColumn ? /* @__PURE__ */ React7__default.default.createElement(TableHeaderContent, {
+    }, header.isPlaceholder ? null : isSelectColumn ? /* @__PURE__ */ React21__default.default.createElement(TableHeaderContent, {
       header
-    }) : /* @__PURE__ */ React7__default.default.createElement(TableHeaderWithPopover, {
+    }) : /* @__PURE__ */ React21__default.default.createElement(TableHeaderWithPopover, {
+      table,
       header,
       isColumnPinned,
-      setColumnPinning: table.setColumnPinning
-    }), header.column.getCanResize() && /* @__PURE__ */ React7__default.default.createElement("div", {
+      columnOptions,
+      featureFlags: headerMenuFeatureFlags,
+      onOpenColumnConfig: handleOpenColumnConfig,
+      onOpenMultiSort: handleOpenMultiSort
+    }), header.column.getCanResize() && headerMenuFeatureFlags?.showResizeItem !== false && /* @__PURE__ */ React21__default.default.createElement("div", {
       className: TableHeader_default.osdkTableHeaderResizer,
       onDoubleClick: () => header.column.resetSize(),
       onMouseDown: header.getResizeHandler(),
       onTouchStart: header.getResizeHandler()
     }));
-  }))));
+  })))), !!columnOptions?.length && /* @__PURE__ */ React21__default.default.createElement(ColumnConfigDialog, {
+    isOpen: configDialogOpen,
+    onClose: handleCloseColumnConfig,
+    columnOptions,
+    currentVisibility,
+    currentColumnOrder,
+    onApply: handleApplyColumnConfig
+  }), columnOptions?.some((col) => col.canSort) && /* @__PURE__ */ React21__default.default.createElement(MultiColumnSortDialog, {
+    isOpen: multiSortDialogOpen,
+    onClose: handleCloseMultiSort,
+    columnOptions,
+    currentSorting,
+    onApply: handleApplyMultiSort
+  }));
 }
 
 // src/object-table/LoadingStateTable.tsx
@@ -753,15 +4464,15 @@ function LoadingStateTable({
   rowHeight = 40,
   columnWidth = 120
 }) {
-  const isSelectionEnabled = table.options.enableRowSelection;
-  const minHeaderCount = isSelectionEnabled ? 1 : 0;
-  const headers = headerGroups[0]?.headers ?? [];
+  const enableRowSelection = table.options.enableRowSelection;
+  const minHeaderCount = enableRowSelection ? 1 : 0;
+  const headers = React21.useMemo(() => headerGroups.length > 0 ? headerGroups[0].headers : [], [headerGroups]);
   const hasHeadersLoaded = headers.length > minHeaderCount;
-  const headerRef = React7.useRef(null);
-  const bodyRef = React7.useRef(null);
-  const [loadingRowCount, setLoadingRowCount] = React7.useState(MIN_ROWS);
-  const [loadingColumnCount, setLoadingColumnCount] = React7.useState(headers.length);
-  React7.useEffect(() => {
+  const headerRef = React21.useRef(null);
+  const bodyRef = React21.useRef(null);
+  const [loadingRowCount, setLoadingRowCount] = React21.useState(MIN_ROWS);
+  const [loadingColumnCount, setLoadingColumnCount] = React21.useState(headers.length);
+  React21.useEffect(() => {
     if (hasHeadersLoaded) {
       setLoadingColumnCount(headers.length);
     } else {
@@ -774,7 +4485,7 @@ function LoadingStateTable({
       }
     }
   }, [columnWidth, hasHeadersLoaded, headers, tableContainerRef]);
-  React7.useEffect(() => {
+  React21.useEffect(() => {
     if (tableContainerRef.current) {
       const containerHeight = tableContainerRef.current.clientHeight;
       const availableHeight = containerHeight - rowHeight;
@@ -784,32 +4495,32 @@ function LoadingStateTable({
       }
     }
   }, [tableContainerRef, rowHeight]);
-  return /* @__PURE__ */ React7__default.default.createElement(React7__default.default.Fragment, null, hasHeadersLoaded ? /* @__PURE__ */ React7__default.default.createElement(TableHeader, {
+  return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, hasHeadersLoaded ? /* @__PURE__ */ React21__default.default.createElement(TableHeader, {
     table
-  }) : /* @__PURE__ */ React7__default.default.createElement("thead", {
+  }) : /* @__PURE__ */ React21__default.default.createElement("thead", {
     className: TableHeader_default.osdkTableHeader,
     ref: headerRef
-  }, /* @__PURE__ */ React7__default.default.createElement("tr", {
+  }, /* @__PURE__ */ React21__default.default.createElement("tr", {
     className: TableHeader_default.osdkTableHeaderRow
   }, Array.from({
     length: loadingColumnCount
   }).map((_, index) => {
     const width = headers.length > index ? headers[index].getSize() : columnWidth;
-    return /* @__PURE__ */ React7__default.default.createElement("th", {
+    return /* @__PURE__ */ React21__default.default.createElement("th", {
       key: `loading-header-${index}`,
       className: TableHeader_default.osdkTableHeaderCell,
       style: {
         width
       }
-    }, /* @__PURE__ */ React7__default.default.createElement("div", {
-      className: classNames2__default.default(TableHeader_default.osdkLoadingHeaderCell, LoadingCell_default.osdkCellSkeleton)
+    }, /* @__PURE__ */ React21__default.default.createElement("div", {
+      className: classnames7__default.default(TableHeader_default.osdkLoadingHeaderCell, LoadingCell_default.osdkCellSkeleton)
     }));
-  }))), /* @__PURE__ */ React7__default.default.createElement("tbody", {
+  }))), /* @__PURE__ */ React21__default.default.createElement("tbody", {
     className: TableBody_default.osdkTableBody,
     ref: bodyRef
   }, Array.from({
     length: loadingRowCount
-  }).map((_, index) => /* @__PURE__ */ React7__default.default.createElement(LoadingRow, {
+  }).map((_, index) => /* @__PURE__ */ React21__default.default.createElement(LoadingRow, {
     key: `skeleton-${index}`,
     columnCount: loadingColumnCount,
     headers,
@@ -826,9 +4537,9 @@ var NonIdealState_default = {};
 function NonIdealState({
   message
 }) {
-  return /* @__PURE__ */ React7__default.default.createElement("div", {
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
     className: NonIdealState_default.container
-  }, /* @__PURE__ */ React7__default.default.createElement("div", {
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
     className: NonIdealState_default.message
   }, message));
 }
@@ -846,8 +4557,8 @@ function CellContextMenu({
   onClose,
   renderContent
 }) {
-  const ref = React7.useRef(null);
-  React7.useEffect(() => {
+  const ref = React21.useRef(null);
+  React21.useEffect(() => {
     const handleClickOutside = (event) => {
       if (ref.current && !ref.current.contains(event.target)) {
         onClose();
@@ -858,7 +4569,7 @@ function CellContextMenu({
       document.removeEventListener("mousedown", handleClickOutside);
     };
   }, [onClose]);
-  return /* @__PURE__ */ reactDom.createPortal(/* @__PURE__ */ React7__default.default.createElement("div", {
+  return /* @__PURE__ */ reactDom.createPortal(/* @__PURE__ */ React21__default.default.createElement("div", {
     ref,
     className: CellContextMenu_default.osdkCellContextMenu,
     style: {
@@ -871,9 +4582,9 @@ function CellContextMenu({
 var useCellContextMenu = ({
   tdRef
 }) => {
-  const [popoverPosition, setPopoverPosition] = React7.useState(null);
-  const [isContextMenuOpen, setIsContextMenuOpen] = React7.useState(false);
-  const handleOpenContextMenu = React7.useCallback((event) => {
+  const [popoverPosition, setPopoverPosition] = React21.useState(null);
+  const [isContextMenuOpen, setIsContextMenuOpen] = React21.useState(false);
+  const handleOpenContextMenu = React21.useCallback((event) => {
     event.preventDefault();
     event.stopPropagation();
     if (tdRef.current) {
@@ -887,7 +4598,7 @@ var useCellContextMenu = ({
       setIsContextMenuOpen(true);
     }
   }, [tdRef]);
-  const handleCloseContextMenu = React7.useCallback(() => {
+  const handleCloseContextMenu = React21.useCallback(() => {
     setIsContextMenuOpen(false);
     setPopoverPosition(null);
   }, []);
@@ -904,7 +4615,7 @@ function TableCell({
   cell,
   renderCellContextMenu
 }) {
-  const tdRef = React7.useRef(null);
+  const tdRef = React21.useRef(null);
   const isSelectColumn = cell.column.id === SELECTION_COLUMN_ID;
   const {
     isContextMenuOpen,
@@ -918,15 +4629,15 @@ function TableCell({
   const {
     columnStyles
   } = getColumnPinningStyles(cell.column);
-  return /* @__PURE__ */ React7__default.default.createElement(React7__default.default.Fragment, null, /* @__PURE__ */ React7__default.default.createElement("td", {
+  return /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement("td", {
     ref: tdRef,
     "data-pinned": cell.column.getIsPinned(),
     className: TableCell_default.osdkTableCell,
     style: columnStyles,
     onContextMenu: handleOpenContextMenu
-  }, /* @__PURE__ */ React7__default.default.createElement("div", {
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
     className: TableCell_default.osdkTableCellContent
-  }, reactTable.flexRender(cell.column.columnDef.cell, cell.getContext()))), shouldRenderContextMenu && /* @__PURE__ */ React7__default.default.createElement(CellContextMenu, {
+  }, reactTable.flexRender(cell.column.columnDef.cell, cell.getContext()))), shouldRenderContextMenu && /* @__PURE__ */ React21__default.default.createElement(CellContextMenu, {
     cell,
     position: popoverPosition,
     onClose: handleCloseContextMenu,
@@ -941,10 +4652,10 @@ function TableRow({
   onRowClick,
   renderCellContextMenu
 }) {
-  const handleClick = React7.useCallback(() => {
+  const handleClick = React21.useCallback(() => {
     onRowClick?.(row.original);
   }, [onRowClick, row.original]);
-  return /* @__PURE__ */ React7__default.default.createElement("tr", {
+  return /* @__PURE__ */ React21__default.default.createElement("tr", {
     "data-selected": row.getIsSelected(),
     className: TableRow_default.osdkTableRow,
     style: {
@@ -952,7 +4663,7 @@ function TableRow({
       transform: `translateY(${virtualRow.start}px)`
     },
     onClick: handleClick
-  }, row.getVisibleCells().map((cell) => /* @__PURE__ */ React7__default.default.createElement(TableCell, {
+  }, row.getVisibleCells().map((cell) => /* @__PURE__ */ React21__default.default.createElement(TableCell, {
     key: cell.id,
     cell,
     renderCellContextMenu
@@ -975,27 +4686,27 @@ function TableBody({
     getScrollElement: () => tableContainerRef.current,
     overscan: 5
   });
-  React7.useLayoutEffect(() => {
+  React21.useLayoutEffect(() => {
     rowVirtualizer.measure();
   }, [rowVirtualizer, rows.length]);
   const totalSize = rowVirtualizer.getTotalSize();
   const bodyHeight = isLoadingMore ? totalSize + rowHeight : totalSize;
   const headers = headerGroups[0]?.headers ?? [];
-  return /* @__PURE__ */ React7__default.default.createElement("tbody", {
+  return /* @__PURE__ */ React21__default.default.createElement("tbody", {
     className: TableBody_default.osdkTableBody,
     style: {
       height: `${bodyHeight}px`
     }
   }, rowVirtualizer.getVirtualItems().map((virtualRow) => {
     const row = rows[virtualRow.index];
-    return /* @__PURE__ */ React7__default.default.createElement(TableRow, {
+    return /* @__PURE__ */ React21__default.default.createElement(TableRow, {
       key: row.id,
       row,
       virtualRow,
       onRowClick,
       renderCellContextMenu
     });
-  }), isLoadingMore && /* @__PURE__ */ React7__default.default.createElement(LoadingRow, {
+  }), isLoadingMore && /* @__PURE__ */ React21__default.default.createElement(LoadingRow, {
     headers,
     translateY: totalSize,
     rowHeight,
@@ -1012,17 +4723,19 @@ function BaseTable({
   rowHeight,
   renderCellContextMenu,
   className,
-  error
+  error,
+  headerMenuFeatureFlags,
+  editableConfig
 }) {
-  const tableContainerRef = React7.useRef(null);
-  const [isLoadingMore, setIsLoadingMore] = React7.useState(false);
-  const fetchingRef = React7.useRef(false);
-  React7.useEffect(() => {
+  const tableContainerRef = React21.useRef(null);
+  const [isLoadingMore, setIsLoadingMore] = React21.useState(false);
+  const fetchingRef = React21.useRef(false);
+  React21.useEffect(() => {
     if (!isLoading || fetchNextPage == null) {
       setIsLoadingMore(false);
     }
   }, [isLoading, fetchNextPage]);
-  const fetchMoreOnEndReached = React7.useCallback(async (containerRefElement) => {
+  const fetchMoreOnEndReached = React21.useCallback(async (containerRefElement) => {
     if (containerRefElement && !fetchingRef.current && !isLoadingMore) {
       const {
         scrollHeight,
@@ -1040,26 +4753,32 @@ function BaseTable({
       }
     }
   }, [fetchNextPage, isLoading, isLoadingMore]);
-  const handleScroll = React7.useCallback(async (e) => {
+  const handleScroll = React21.useCallback(async (e) => {
     await fetchMoreOnEndReached(e.currentTarget);
   }, [fetchMoreOnEndReached]);
   const rows = table.getRowModel().rows;
   const headerGroups = table.getHeaderGroups();
   const hasData = rows.length > 0;
-  return /* @__PURE__ */ React7__default.default.createElement("div", {
+  const hasEdits = Object.keys(editableConfig?.cellEdits ?? {}).length > 0;
+  const handleSubmitEdits = React21.useCallback(async () => {
+    await editableConfig?.onSubmitEdits?.();
+    editableConfig?.clearEdits?.();
+  }, [editableConfig]);
+  return /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: classnames7__default.default(Table_default.osdkTableWrapper, className)
+  }, /* @__PURE__ */ React21__default.default.createElement("div", {
     ref: tableContainerRef,
-    className: classNames2__default.default(Table_default.osdkTableContainer, className),
+    className: classnames7__default.default(Table_default.osdkTableContainer, editableConfig && Table_default.osdkTableContainerWithButton),
     onScroll: handleScroll
-  }, /* @__PURE__ */ React7__default.default.createElement("table", null, isLoading && !hasData ? /* @__PURE__ */ React7__default.default.createElement(LoadingStateTable, {
+  }, /* @__PURE__ */ React21__default.default.createElement("table", null, isLoading && !hasData ? /* @__PURE__ */ React21__default.default.createElement(LoadingStateTable, {
     table,
     headerGroups,
     rowHeight,
     tableContainerRef
-  }) : /* @__PURE__ */ React7__default.default.createElement(React7__default.default.Fragment, null, /* @__PURE__ */ React7__default.default.createElement(TableHeader, {
-    table
-  }), !hasData && error == null ? /* @__PURE__ */ React7__default.default.createElement(NonIdealState, {
-    message: "No Data"
-  }) : /* @__PURE__ */ React7__default.default.createElement(TableBody, {
+  }) : /* @__PURE__ */ React21__default.default.createElement(React21__default.default.Fragment, null, /* @__PURE__ */ React21__default.default.createElement(TableHeader, {
+    table,
+    headerMenuFeatureFlags
+  }), /* @__PURE__ */ React21__default.default.createElement(TableBody, {
     rows,
     tableContainerRef,
     onRowClick,
@@ -1067,27 +4786,59 @@ function BaseTable({
     renderCellContextMenu,
     isLoadingMore,
     headerGroups
-  })), error != null && /* @__PURE__ */ React7__default.default.createElement(NonIdealState, {
+  }))), !hasData && error == null && /* @__PURE__ */ React21__default.default.createElement(NonIdealState, {
+    message: "No Data"
+  }), error != null && /* @__PURE__ */ React21__default.default.createElement(NonIdealState, {
     message: `Error Loading Data: ${error.message}`
-  })));
+  })), editableConfig && /* @__PURE__ */ React21__default.default.createElement("div", {
+    className: Table_default.submitButtonContainer
+  }, /* @__PURE__ */ React21__default.default.createElement(ActionButton, {
+    variant: "primary",
+    onClick: handleSubmitEdits,
+    disabled: !hasEdits
+  }, "Submit Edits")));
 }
 
 // src/object-table/ObjectTable.tsx
 function ObjectTable({
   objectType,
+  objectSet,
   columnDefinitions,
   filter,
+  objectSetOptions,
   orderBy,
   defaultOrderBy,
   onOrderByChanged,
   onColumnsPinnedChanged,
+  onColumnResize,
   onRowSelection,
   renderCellContextMenu,
   selectionMode = "none",
   selectedRows,
+  onColumnVisibilityChanged,
+  onCellValueChanged,
+  onSubmitEdits,
+  enableOrdering = true,
+  enableColumnPinning = true,
+  enableColumnResizing = true,
+  enableColumnConfig = true,
   ...props
 }) {
-  const [columnSizing, setColumnSizing] = React7.useState({});
+  const {
+    columnSizing,
+    onColumnSizingChange
+  } = useColumnResize({
+    onColumnResize
+  });
+  const {
+    cellEdits,
+    clearEdits,
+    handleCellEdit,
+    handleSubmitEdits
+  } = useEditableTable({
+    onCellValueChanged,
+    onSubmitEdits
+  });
   const {
     sorting,
     onSortingChange
@@ -1101,20 +4852,18 @@ function ObjectTable({
     fetchMore,
     isLoading,
     error
-  } = useObjectTableData(objectType, columnDefinitions, filter, sorting);
+  } = useObjectTableData(objectType, columnDefinitions, filter, sorting, objectSet, objectSetOptions);
   const {
     columns,
     loading: isColumnsLoading
   } = useColumnDefs(objectType, columnDefinitions);
-  const columnVisibility = useColumnVisibility({
-    columnDefinitions
-  });
   const {
     rowSelection,
     isAllSelected,
     hasSelection,
     onToggleAll,
-    onToggleRow
+    onToggleRow,
+    enableRowSelection
   } = useRowSelection({
     selectionMode,
     selectedRows,
@@ -1128,32 +4877,45 @@ function ObjectTable({
     onToggleAll,
     onToggleRow
   });
-  const allColumns = React7.useMemo(() => {
-    return selectionColumn ? [selectionColumn, ...columns] : columns;
-  }, [selectionColumn, columns]);
+  const {
+    columnVisibility,
+    onColumnVisibilityChange,
+    columnOrder,
+    onColumnOrderChange
+  } = useColumnVisibility({
+    allColumns: columns,
+    onColumnVisibilityChanged
+  });
   const {
     columnPinning,
     onColumnPinningChange
   } = useColumnPinning({
     columnDefinitions,
-    hasSelectionColumn: selectionColumn != null,
+    hasSelectionColumn: enableRowSelection,
     onColumnsPinnedChanged
   });
+  const allColumns = React21.useMemo(() => {
+    return selectionColumn ? [selectionColumn, ...columns] : columns;
+  }, [selectionColumn, columns]);
   const table = reactTable.useReactTable({
     data: data ?? [],
     columns: allColumns,
     getCoreRowModel: reactTable.getCoreRowModel(),
     state: {
       columnVisibility,
+      columnOrder,
       rowSelection,
       sorting,
       columnSizing,
       columnPinning
     },
     onSortingChange,
-    onColumnSizingChange: setColumnSizing,
+    onColumnSizingChange,
     onColumnPinningChange,
-    enableRowSelection: selectionMode !== "none",
+    onColumnVisibilityChange,
+    onColumnOrderChange,
+    enableRowSelection,
+    enableSorting: enableOrdering,
     columnResizeMode: "onChange",
     columnResizeDirection: "ltr",
     manualSorting: true,
@@ -1161,13 +4923,33 @@ function ObjectTable({
     defaultColumn: {
       minSize: 80
     },
-    getRowId
+    getRowId,
+    meta: {
+      onCellEdit: handleCellEdit,
+      cellEdits
+    }
   });
-  const onRenderCellContextMenu = React7.useCallback((row, cell) => {
+  const onRenderCellContextMenu = React21.useCallback((row, cell) => {
     return renderCellContextMenu?.(row, cell.getValue());
   }, [renderCellContextMenu]);
   const isTableLoading = isLoading || isColumnsLoading;
-  return /* @__PURE__ */ React7__default.default.createElement(BaseTable, {
+  const headerMenuFeatureFlags = React21.useMemo(() => ({
+    showSortingItems: enableOrdering,
+    showPinningItems: enableColumnPinning,
+    showResizeItem: enableColumnResizing,
+    showConfigItem: enableColumnConfig
+  }), [enableOrdering, enableColumnPinning, enableColumnResizing, enableColumnConfig]);
+  const editableConfig = React21.useMemo(() => {
+    if (!onSubmitEdits) {
+      return;
+    }
+    return {
+      onSubmitEdits: handleSubmitEdits,
+      clearEdits,
+      cellEdits
+    };
+  }, [onSubmitEdits, handleSubmitEdits, clearEdits, cellEdits]);
+  return /* @__PURE__ */ React21__default.default.createElement(BaseTable, {
     table,
     isLoading: isTableLoading,
     fetchNextPage: fetchMore,
@@ -1175,11 +4957,15 @@ function ObjectTable({
     rowHeight: props.rowHeight,
     renderCellContextMenu: onRenderCellContextMenu,
     className: props.className,
-    error
+    error,
+    headerMenuFeatureFlags,
+    editableConfig
   });
 }
 
 exports.BaseTable = BaseTable;
+exports.ColumnConfigDialog = ColumnConfigDialog;
+exports.FilterList = FilterList;
 exports.ObjectTable = ObjectTable;
 //# sourceMappingURL=experimental.cjs.map
 //# sourceMappingURL=experimental.cjs.map