@powerduck/schema-designer 0.1.0

package/dist/chunk-GWHDTTQK.js

@@ -0,0 +1,1437 @@
+import { SettingsPanel, InlineSchemaEditor_default, InlineSchemaEditor } from './chunk-2XUQB6BQ.js';
+import { VariableTextEditor } from './chunk-BXFABOMJ.js';
+import { parameterKey, parameterValueText } from './chunk-ZHNYNFGL.js';
+import { resolveParameterValue, resolveParameterType } from './chunk-MADPN2PJ.js';
+import { createSchemaForType } from './chunk-HI5FBHCO.js';
+import { nanoid } from 'nanoid';
+import { VscSettingsCompact } from 'react-icons/vsc';
+import { Box, createListCollection, Text, Table, Flex, Checkbox, Span, Select, Portal, ActionBar, Button, Popover, Tabs, Stack, Field, NativeSelect, Switch, Input } from '@chakra-ui/react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { memo, useState, useRef, useEffect, useMemo, useLayoutEffect, useCallback } from 'react';
+import { DragDropContext, Droppable, Draggable } from '@hello-pangea/dnd';
+import { LuGripVertical, LuRefreshCw } from 'react-icons/lu';
+import { AiOutlineDelete } from 'react-icons/ai';
+
+// src/react/parametersTable/libs/columns.ts
+var DEFAULT_COLUMNS = [
+  { id: "name", label: "Name", defaultWidth: 180, minWidth: 160 },
+  { id: "value", label: "Value", defaultWidth: 220, minWidth: 120 },
+  { id: "type", label: "Type", defaultWidth: 140, minWidth: 120 },
+  {
+    id: "required",
+    label: "Required",
+    defaultWidth: 100,
+    minWidth: 100,
+    maxWidth: 140
+  },
+  { id: "description", label: "Description", defaultWidth: 360, minWidth: 180 }
+];
+function getVisibleColumns(args) {
+  const { showRequired, showType, showDescription } = args;
+  return DEFAULT_COLUMNS.filter((c) => {
+    if (c.id === "required" && !showRequired) return false;
+    if (c.id === "type" && !showType) return false;
+    if (c.id === "description" && !showDescription) return false;
+    return true;
+  });
+}
+function getRightNeighborId(visibleColumns, columnId) {
+  const idx = visibleColumns.findIndex((c) => c.id === columnId);
+  if (idx < 0) return null;
+  return visibleColumns[idx + 1]?.id ?? null;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function buildColumnDefsById(columns) {
+  return columns.reduce(
+    (acc, c) => {
+      acc[c.id] = c;
+      return acc;
+    },
+    {}
+  );
+}
+function fitColumnWidths(previous, columns, available) {
+  if (!columns.length || !Number.isFinite(available) || available <= 0)
+    return previous;
+  const minimum = columns.reduce((sum, column) => sum + column.minWidth, 0);
+  const maximum = columns.reduce(
+    (sum, column) => sum + (column.maxWidth ?? Infinity),
+    0
+  );
+  const target = Math.max(minimum, Math.min(maximum, available));
+  const currentTotal = columns.reduce(
+    (sum, column) => sum + previous[column.id],
+    0
+  );
+  const valid = columns.every(
+    (column) => Number.isFinite(previous[column.id]) && previous[column.id] >= column.minWidth && previous[column.id] <= (column.maxWidth ?? Infinity)
+  );
+  if (valid && Math.abs(currentTotal - target) < 0.01) return previous;
+  const weights = columns.map(
+    (column) => Math.max(
+      1,
+      Number.isFinite(previous[column.id]) ? previous[column.id] : column.defaultWidth
+    )
+  );
+  const widthAt = (index, scale) => Math.max(
+    columns[index].minWidth,
+    Math.min(columns[index].maxWidth ?? Infinity, weights[index] * scale)
+  );
+  let low = 0;
+  let high = Math.max(1, target / Math.min(...weights));
+  for (let iteration = 0; iteration < 40; iteration += 1) {
+    const middle = (low + high) / 2;
+    const total = columns.reduce(
+      (sum, _, index) => sum + widthAt(index, middle),
+      0
+    );
+    if (total < target) low = middle;
+    else high = middle;
+  }
+  const next = { ...previous };
+  columns.forEach((column, index) => {
+    next[column.id] = widthAt(index, (low + high) / 2);
+  });
+  return columns.every(
+    (column) => Math.abs(previous[column.id] - next[column.id]) < 0.01
+  ) ? previous : next;
+}
+
+// src/react/parametersTable/libs/splitterResize.ts
+var EPSILON = 1e-3;
+function finiteOr(value, fallback) {
+  return Number.isFinite(value) ? value : fallback;
+}
+function normalizeBounds(min, max) {
+  const safeMin = Math.max(0, finiteOr(min, 0));
+  const safeMax = Number.isFinite(max) ? Math.max(safeMin, max) : Number.POSITIVE_INFINITY;
+  return [safeMin, safeMax];
+}
+function clamp2(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+function applyAdjacentSplitterResize({
+  session,
+  clientX,
+  widths
+}) {
+  if (!Number.isFinite(clientX)) {
+    return widths;
+  }
+  const { leftId, rightId, startClientX } = session;
+  if (!Number.isFinite(startClientX)) {
+    return widths;
+  }
+  const startLeftWidth = Math.max(
+    0,
+    finiteOr(session.startLeftWidth, widths[leftId] ?? 0)
+  );
+  const startRightWidth = Math.max(
+    0,
+    finiteOr(session.startRightWidth, widths[rightId] ?? 0)
+  );
+  const totalWidth = startLeftWidth + startRightWidth;
+  if (!Number.isFinite(totalWidth) || totalWidth <= 0) {
+    return widths;
+  }
+  const [leftMin, leftMax] = normalizeBounds(
+    session.leftMinWidth,
+    session.leftMaxWidth
+  );
+  const [rightMin, rightMax] = normalizeBounds(
+    session.rightMinWidth,
+    session.rightMaxWidth
+  );
+  const feasibleLeftMin = Math.max(
+    leftMin,
+    Number.isFinite(rightMax) ? totalWidth - rightMax : 0
+  );
+  const feasibleLeftMax = Math.min(leftMax, totalWidth - rightMin);
+  if (feasibleLeftMin > feasibleLeftMax + EPSILON) {
+    return widths;
+  }
+  const delta = clientX - startClientX;
+  const requestedLeft = startLeftWidth + delta;
+  const nextLeft = clamp2(requestedLeft, feasibleLeftMin, feasibleLeftMax);
+  const nextRight = totalWidth - nextLeft;
+  if (nextLeft < leftMin - EPSILON || nextLeft > leftMax + EPSILON || nextRight < rightMin - EPSILON || nextRight > rightMax + EPSILON) {
+    return widths;
+  }
+  const currentLeft = widths[leftId];
+  const currentRight = widths[rightId];
+  if (Number.isFinite(currentLeft) && Number.isFinite(currentRight) && Math.abs(currentLeft - nextLeft) < EPSILON && Math.abs(currentRight - nextRight) < EPSILON) {
+    return widths;
+  }
+  return {
+    ...widths,
+    [leftId]: nextLeft,
+    [rightId]: nextRight
+  };
+}
+
+// src/react/parametersTable/libs/reorder.ts
+function reorder(list, startIndex, endIndex) {
+  if (!Number.isInteger(startIndex) || !Number.isInteger(endIndex) || startIndex < 0 || endIndex < 0 || startIndex >= list.length || endIndex >= list.length || startIndex === endIndex)
+    return list;
+  const result = [...list];
+  const [removed] = result.splice(startIndex, 1);
+  result.splice(endIndex, 0, removed);
+  return result;
+}
+function createRows(parameters) {
+  return parameters.map((parameter) => ({
+    id: nanoid(),
+    parameter
+  }));
+}
+function getDisplayValue(row, document) {
+  const resolved = resolveParameterValue(row.parameter, document);
+  if (Object.prototype.hasOwnProperty.call(row, "generatedValue")) {
+    return { value: row.generatedValue, source: "generated" };
+  }
+  return resolved;
+}
+function areParametersEqual(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+function areParameterArraysEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i += 1) {
+    if (!areParametersEqual(a[i], b[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function reconcileRows(previous, parameters) {
+  if (parameters.length === previous.length && parameters.every(
+    (parameter, index) => parameter === previous[index].parameter
+  ))
+    return previous;
+  if (parameters.length === 0) {
+    return [];
+  }
+  const previousByKey = /* @__PURE__ */ new Map();
+  for (const row of previous) {
+    const name = String(row.parameter.name ?? "");
+    const location = String(
+      row.parameter.in ?? ""
+    );
+    const key = `${location}\0${name}`;
+    const bucket = previousByKey.get(key);
+    if (bucket) {
+      bucket.push(row);
+    } else {
+      previousByKey.set(key, [row]);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  return parameters.map((parameter) => {
+    const name = String(parameter.name ?? "");
+    const location = String(
+      parameter.in ?? ""
+    );
+    const key = `${location}\0${name}`;
+    const bucket = previousByKey.get(key);
+    if (bucket) {
+      while (bucket.length > 0) {
+        const candidate = bucket.shift();
+        if (candidate && !used.has(candidate.id)) {
+          used.add(candidate.id);
+          return candidate.parameter === parameter ? candidate : { ...candidate, parameter };
+        }
+      }
+    }
+    return {
+      id: nanoid(),
+      parameter
+    };
+  });
+}
+function ParameterSettings({
+  parameter,
+  document,
+  disabled,
+  onChange
+}) {
+  const patch = (value) => {
+    if (!disabled) onChange({ ...parameter, ...value });
+  };
+  return /* @__PURE__ */ jsxs(
+    Popover.Root,
+    {
+      lazyMount: true,
+      unmountOnExit: true,
+      positioning: {
+        placement: "bottom-start",
+        strategy: "fixed",
+        overflowPadding: 12
+      },
+      children: [
+        /* @__PURE__ */ jsx(Popover.Trigger, { asChild: true, children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            width: "24px",
+            minWidth: "24px",
+            height: "24px",
+            padding: "0",
+            size: "xs",
+            variant: "ghost",
+            "aria-label": `Configure ${parameter.name}`,
+            title: `Configure ${parameter.name}`,
+            children: /* @__PURE__ */ jsx(VscSettingsCompact, { size: 16 })
+          }
+        ) }),
+        /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(Popover.Positioner, { children: /* @__PURE__ */ jsx(SettingsPanel, { title: parameter.name || "Parameter", children: /* @__PURE__ */ jsx("div", { className: InlineSchemaEditor_default.root, children: /* @__PURE__ */ jsxs(
+          Tabs.Root,
+          {
+            variant: "plain",
+            defaultValue: "schema",
+            lazyMount: true,
+            unmountOnExit: true,
+            children: [
+              /* @__PURE__ */ jsxs(Tabs.List, { children: [
+                /* @__PURE__ */ jsx(Tabs.Trigger, { value: "schema", children: "Schema" }),
+                /* @__PURE__ */ jsx(Tabs.Trigger, { value: "parameter", children: "Parameter" })
+              ] }),
+              /* @__PURE__ */ jsx(Tabs.Content, { value: "parameter", pt: "2", children: /* @__PURE__ */ jsxs(Stack, { gap: "2", children: [
+                /* @__PURE__ */ jsxs(Field.Root, { children: [
+                  /* @__PURE__ */ jsx(Field.Label, { children: "Location" }),
+                  /* @__PURE__ */ jsx(NativeSelect.Root, { disabled, children: /* @__PURE__ */ jsx(
+                    NativeSelect.Field,
+                    {
+                      value: parameter.in,
+                      onChange: (event) => {
+                        const location = event.target.value;
+                        patch({
+                          in: location,
+                          required: location === "path" ? true : parameter.required
+                        });
+                      },
+                      children: [
+                        "query",
+                        "header",
+                        "path",
+                        "cookie",
+                        "querystring"
+                      ].map((value) => /* @__PURE__ */ jsx("option", { children: value }, value))
+                    }
+                  ) })
+                ] }),
+                /* @__PURE__ */ jsxs(
+                  Switch.Root,
+                  {
+                    checked: parameter.in === "path" || !!parameter.required,
+                    disabled: disabled || parameter.in === "path",
+                    onCheckedChange: (event) => patch({ required: event.checked }),
+                    children: [
+                      /* @__PURE__ */ jsx(Switch.HiddenInput, {}),
+                      /* @__PURE__ */ jsx(Switch.Control, {}),
+                      /* @__PURE__ */ jsx(Switch.Label, { children: "Required" })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsxs(Field.Root, { children: [
+                  /* @__PURE__ */ jsx(Field.Label, { children: "Description" }),
+                  /* @__PURE__ */ jsx(
+                    Input,
+                    {
+                      value: parameter.description ?? "",
+                      disabled,
+                      onChange: (event) => patch({ description: event.target.value })
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxs("details", { className: InlineSchemaEditor_default.reference, children: [
+                  /* @__PURE__ */ jsx("summary", { children: "Serialization" }),
+                  /* @__PURE__ */ jsxs(Stack, { gap: "2", pt: "2", children: [
+                    /* @__PURE__ */ jsxs(Field.Root, { children: [
+                      /* @__PURE__ */ jsx(Field.Label, { children: "Serialization style" }),
+                      /* @__PURE__ */ jsx(
+                        Input,
+                        {
+                          value: parameter.style ?? "",
+                          disabled,
+                          placeholder: "Default for location",
+                          onChange: (event) => patch({ style: event.target.value || void 0 })
+                        }
+                      )
+                    ] }),
+                    /* @__PURE__ */ jsxs(
+                      Switch.Root,
+                      {
+                        checked: !!parameter.explode,
+                        disabled,
+                        onCheckedChange: (event) => patch({ explode: event.checked }),
+                        children: [
+                          /* @__PURE__ */ jsx(Switch.HiddenInput, {}),
+                          /* @__PURE__ */ jsx(Switch.Control, {}),
+                          /* @__PURE__ */ jsx(Switch.Label, { children: "Explode" })
+                        ]
+                      }
+                    ),
+                    /* @__PURE__ */ jsxs(
+                      Switch.Root,
+                      {
+                        checked: !!parameter.allowReserved,
+                        disabled,
+                        onCheckedChange: (event) => patch({ allowReserved: event.checked }),
+                        children: [
+                          /* @__PURE__ */ jsx(Switch.HiddenInput, {}),
+                          /* @__PURE__ */ jsx(Switch.Control, {}),
+                          /* @__PURE__ */ jsx(Switch.Label, { children: "Allow reserved characters" })
+                        ]
+                      }
+                    )
+                  ] })
+                ] })
+              ] }) }),
+              /* @__PURE__ */ jsx(Tabs.Content, { value: "schema", pt: "2", children: parameter.content ? /* @__PURE__ */ jsx("p", { children: "This parameter uses content. Its media type schema is preserved." }) : /* @__PURE__ */ jsx(
+                InlineSchemaEditor,
+                {
+                  schema: parameter.schema ?? {},
+                  fullSchema: document,
+                  nested: true,
+                  disabled,
+                  onChange: (value) => patch({ schema: value })
+                }
+              ) })
+            ]
+          }
+        ) }) }) }) })
+      ]
+    }
+  );
+}
+
+// src/react/parametersTable/ParametersTable.module.css
+var ParametersTable_default = {
+  root: "ParametersTable_root",
+  tableViewport: "ParametersTable_tableViewport",
+  tableContainer: "ParametersTable_tableContainer",
+  table: "ParametersTable_table",
+  colCheckbox: "ParametersTable_colCheckbox",
+  colData: "ParametersTable_colData",
+  headerCell: "ParametersTable_headerCell",
+  checkboxCell: "ParametersTable_checkboxCell",
+  headerContent: "ParametersTable_headerContent",
+  headerLabel: "ParametersTable_headerLabel",
+  resizeHandle: "ParametersTable_resizeHandle",
+  variableTextEditor: "ParametersTable_variableTextEditor",
+  row: "ParametersTable_row",
+  cell: "ParametersTable_cell",
+  nameCell: "ParametersTable_nameCell",
+  checkboxCellGroup: "ParametersTable_checkboxCellGroup",
+  checkboxRoot: "ParametersTable_checkboxRoot",
+  dragHandleWrap: "ParametersTable_dragHandleWrap",
+  dragHandle: "ParametersTable_dragHandle",
+  description: "ParametersTable_description",
+  required: "ParametersTable_required",
+  optional: "ParametersTable_optional",
+  empty: "ParametersTable_empty",
+  actionBarContent: "ParametersTable_actionBarContent",
+  actionBarLeft: "ParametersTable_actionBarLeft",
+  actionBarTrigger: "ParametersTable_actionBarTrigger",
+  actionBarDivider: "ParametersTable_actionBarDivider",
+  actionButton: "ParametersTable_actionButton",
+  actionButtonAccent: "ParametersTable_actionButtonAccent",
+  actionIcon: "ParametersTable_actionIcon"
+};
+var EMPTY_VARIABLES = Object.freeze([]);
+var CHECKBOX_COLUMN_WIDTH = 48;
+var RowDragHandle = memo(function RowDragHandle2() {
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      className: ParametersTable_default.dragHandle,
+      "aria-label": "Drag to reorder",
+      role: "button",
+      children: /* @__PURE__ */ jsx(LuGripVertical, { size: 14 })
+    }
+  );
+});
+var ParameterTable = memo(function ParameterTable2(props) {
+  const {
+    parameters,
+    onChange,
+    onSelectionChange,
+    onRowReorder,
+    generateValue,
+    faker,
+    emptyState,
+    showRequired = false,
+    showType = false,
+    showDescription = false,
+    stickyHeader = true,
+    height = "100%",
+    className
+  } = props;
+  const readOnly = props.readOnly === true;
+  const requestMode = props.mode === "request";
+  const [generationError, setGenerationError] = useState(null);
+  const generationRef = useRef(null);
+  const rowsRef = useRef([]);
+  useEffect(() => () => generationRef.current?.abort(), []);
+  const [rows, setRows] = useState(
+    () => createRows(parameters)
+  );
+  rowsRef.current = rows;
+  const hasRows = rows.length > 0;
+  useEffect(() => {
+    generationRef.current?.abort();
+  }, [readOnly, requestMode, props.document]);
+  const [selectedIds, setSelectedIds] = useState(() => /* @__PURE__ */ new Set());
+  const lastEmittedParametersRef = useRef(
+    null
+  );
+  const visibleColumns = useMemo(
+    () => getVisibleColumns({
+      showRequired,
+      showType,
+      showDescription
+    }),
+    [showRequired, showType, showDescription]
+  );
+  const columnDefsById = useMemo(
+    () => buildColumnDefsById(DEFAULT_COLUMNS),
+    []
+  );
+  const [columnWidths, setColumnWidths] = useState(
+    () => {
+      const initial = {};
+      for (const column of DEFAULT_COLUMNS) {
+        initial[column.id] = column.defaultWidth;
+      }
+      return initial;
+    }
+  );
+  const widthsByLayoutRef = useRef(/* @__PURE__ */ new Map());
+  const activeLayoutRef = useRef(null);
+  const currentWidthsRef = useRef(columnWidths);
+  currentWidthsRef.current = columnWidths;
+  const viewportRef = useRef(null);
+  const tableRef = useRef(null);
+  const resizeHandleRefs = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    const lastEmitted = lastEmittedParametersRef.current;
+    if (lastEmitted && areParameterArraysEqual(parameters, lastEmitted)) {
+      lastEmittedParametersRef.current = null;
+      return;
+    }
+    setRows((previous) => reconcileRows(previous, parameters));
+    setSelectedIds(/* @__PURE__ */ new Set());
+  }, [parameters]);
+  useEffect(() => {
+    onSelectionChange?.([...selectedIds]);
+  }, [onSelectionChange, selectedIds]);
+  useLayoutEffect(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) return;
+    const layoutKey = visibleColumns.map((column) => column.id).join(",");
+    if (activeLayoutRef.current !== null) {
+      widthsByLayoutRef.current.set(
+        activeLayoutRef.current,
+        currentWidthsRef.current
+      );
+    }
+    activeLayoutRef.current = layoutKey;
+    const restored = widthsByLayoutRef.current.get(layoutKey) ?? Object.fromEntries(
+      DEFAULT_COLUMNS.map((column) => [column.id, column.defaultWidth])
+    );
+    let firstMeasurement = true;
+    let lastWidth = -1;
+    let disposed = false;
+    const synchronize = () => {
+      if (disposed) return;
+      const width = viewport.clientWidth;
+      if (!Number.isFinite(width) || width <= 0 || width === lastWidth) return;
+      lastWidth = width;
+      const baseline = firstMeasurement ? restored : void 0;
+      firstMeasurement = false;
+      setColumnWidths(
+        (previous) => fitColumnWidths(
+          baseline ?? previous,
+          visibleColumns,
+          width - CHECKBOX_COLUMN_WIDTH
+        )
+      );
+    };
+    synchronize();
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", synchronize);
+      return () => {
+        disposed = true;
+        window.removeEventListener("resize", synchronize);
+      };
+    }
+    const observer = new ResizeObserver(synchronize);
+    observer.observe(viewport);
+    return () => {
+      disposed = true;
+      observer.disconnect();
+    };
+  }, [visibleColumns, hasRows]);
+  const [localValues, setLocalValues] = useState({});
+  const effectiveValues = props.values ?? localValues;
+  const controlledValuesRef = useRef(props.values !== void 0);
+  controlledValuesRef.current = props.values !== void 0;
+  const valuesRef = useRef(effectiveValues);
+  valuesRef.current = effectiveValues;
+  const onValuesChangeRef = useRef(props.onValuesChange);
+  onValuesChangeRef.current = props.onValuesChange;
+  const writeValues = (nextRows, changedIds) => {
+    const next = { ...valuesRef.current };
+    for (const row of nextRows) {
+      if (!changedIds.has(row.id)) continue;
+      if (Object.prototype.hasOwnProperty.call(row, "generatedValue")) {
+        const key = parameterKey(row.parameter);
+        next[key] = {
+          enabled: next[key]?.enabled ?? true,
+          value: row.generatedValue
+        };
+      }
+    }
+    if (!controlledValuesRef.current) valuesRef.current = next;
+    setLocalValues(next);
+    onValuesChangeRef.current?.(next);
+  };
+  const editValue = (rowId, value) => {
+    if (readOnly) return;
+    const next = rowsRef.current.map(
+      (row) => row.id === rowId ? { ...row, generatedValue: value } : row
+    );
+    rowsRef.current = next;
+    setRows(next);
+    writeValues(next, /* @__PURE__ */ new Set([rowId]));
+  };
+  const allSelected = rows.length > 0 && rows.every((row) => selectedIds.has(row.id));
+  const someSelected = rows.some((row) => selectedIds.has(row.id)) && !allSelected;
+  const handleSelectAll = useCallback(
+    (checked) => {
+      if (!checked) {
+        setSelectedIds(/* @__PURE__ */ new Set());
+        return;
+      }
+      setSelectedIds(new Set(rows.map((row) => row.id)));
+    },
+    [rows]
+  );
+  const handleSelectRow = useCallback((rowId, checked) => {
+    setSelectedIds((previous) => {
+      const next = new Set(previous);
+      if (checked) {
+        next.add(rowId);
+      } else {
+        next.delete(rowId);
+      }
+      return next;
+    });
+  }, []);
+  const commitRows = useCallback(
+    (nextRows) => {
+      if (readOnly || requestMode) return;
+      rowsRef.current = nextRows;
+      setRows(nextRows);
+      const nextParameters = nextRows.map((row) => row.parameter);
+      lastEmittedParametersRef.current = nextParameters;
+      onChange?.(nextParameters);
+    },
+    [onChange, readOnly, requestMode]
+  );
+  const commitReorder = useCallback(
+    (nextRows) => {
+      if (readOnly || requestMode) return;
+      rowsRef.current = nextRows;
+      setRows(nextRows);
+      const nextParameters = nextRows.map((row) => row.parameter);
+      lastEmittedParametersRef.current = nextParameters;
+      onChange?.(nextParameters);
+      onRowReorder?.(nextParameters);
+    },
+    [onChange, onRowReorder, readOnly, requestMode]
+  );
+  const typeOptions = useMemo(
+    () => createListCollection({
+      items: [
+        {
+          label: "string",
+          value: "string"
+        },
+        {
+          label: "integer",
+          value: "integer"
+        },
+        ...["number", "boolean", "array", "object", "null"].map((value) => ({
+          label: value,
+          value
+        }))
+      ]
+    }),
+    []
+  );
+  const handleGenerate = useCallback(async () => {
+    if (readOnly) return;
+    setGenerationError(null);
+    generationRef.current?.abort();
+    const controller = new AbortController();
+    generationRef.current = controller;
+    const snapshot = rowsRef.current;
+    const valuesSnapshot = valuesRef.current;
+    const generated = /* @__PURE__ */ new Map();
+    await Promise.all(
+      snapshot.map(async (row, rowIndex) => {
+        if (!selectedIds.has(row.id) || !controlledValuesRef.current && Object.prototype.hasOwnProperty.call(row, "generatedValue"))
+          return;
+        const key = parameterKey(row.parameter);
+        if (valuesSnapshot?.[key] || resolveParameterValue(row.parameter, props.document).source !== "missing")
+          return;
+        try {
+          const context = {
+            parameter: row.parameter,
+            rowIndex,
+            signal: controller.signal,
+            document: props.document
+          };
+          const value = generateValue ? await generateValue(context) : faker ? await faker.generate(context) : await import('./react/parametersTable/libs/generateValue.js').then(
+            (module) => module.generateParameterValue(context)
+          );
+          generated.set(row.id, { ...row, generatedValue: value });
+        } catch (error) {
+          if (!controller.signal.aborted) {
+            setGenerationError(
+              error instanceof Error ? error.message : "Value generation failed."
+            );
+            try {
+              props.onError?.(error);
+            } catch {
+            }
+          }
+        }
+      })
+    );
+    if (controller.signal.aborted) return;
+    const originals = new Map(snapshot.map((row) => [row.id, row]));
+    const next = rowsRef.current.map((row) => {
+      const key = parameterKey(row.parameter);
+      return row === originals.get(row.id) && valuesRef.current?.[key] === valuesSnapshot?.[key] ? generated.get(row.id) ?? row : row;
+    });
+    const changedIds = new Set(
+      next.filter((row, index) => row !== rowsRef.current[index]).map((row) => row.id)
+    );
+    if (!changedIds.size) return;
+    rowsRef.current = next;
+    setRows(next);
+    writeValues(next, changedIds);
+  }, [
+    faker,
+    generateValue,
+    selectedIds,
+    readOnly,
+    props.onError,
+    props.document
+  ]);
+  const onDragEnd = useCallback(
+    (result) => {
+      const { destination, source } = result;
+      if (!destination) {
+        return;
+      }
+      if (destination.droppableId !== source.droppableId) {
+        return;
+      }
+      if (destination.index === source.index) {
+        return;
+      }
+      const next = reorder(rows, source.index, destination.index);
+      commitReorder(next);
+    },
+    [commitReorder, rows]
+  );
+  const resizeSessionRef = useRef(null);
+  const resizeRafRef = useRef(null);
+  const pendingResizeSnapshotRef = useRef(null);
+  const resizingColumnRef = useRef(null);
+  const getActualColumnWidth = useCallback(
+    (columnId) => {
+      const header = tableRef.current?.querySelector(
+        `th[data-column="${columnId}"]`
+      );
+      if (!header) {
+        return null;
+      }
+      const width = header.getBoundingClientRect().width;
+      if (!Number.isFinite(width) || width <= 0) {
+        return null;
+      }
+      return width;
+    },
+    []
+  );
+  const cleanupResize = useCallback(() => {
+    resizingColumnRef.current = null;
+    pendingResizeSnapshotRef.current = null;
+    resizeSessionRef.current = null;
+    if (resizeRafRef.current !== null) {
+      window.cancelAnimationFrame(resizeRafRef.current);
+      resizeRafRef.current = null;
+    }
+    const handles = resizeHandleRefs.current;
+    for (const handle of handles.values()) {
+      handle.removeAttribute("data-resizing");
+    }
+  }, []);
+  const onResizeMoveWindow = useCallback((event) => {
+    const session = resizeSessionRef.current;
+    if (!session) {
+      return;
+    }
+    if (session.pointerId !== event.pointerId) {
+      return;
+    }
+    pendingResizeSnapshotRef.current = {
+      clientX: event.clientX,
+      pointerId: event.pointerId
+    };
+    if (resizeRafRef.current !== null) {
+      return;
+    }
+    resizeRafRef.current = window.requestAnimationFrame(() => {
+      resizeRafRef.current = null;
+      const activeSession = resizeSessionRef.current;
+      const snapshot = pendingResizeSnapshotRef.current;
+      if (!activeSession || !snapshot) {
+        return;
+      }
+      if (snapshot.pointerId !== activeSession.pointerId) {
+        return;
+      }
+      const clientX = snapshot.clientX;
+      setColumnWidths(
+        (previous) => applyAdjacentSplitterResize({
+          session: activeSession,
+          clientX,
+          widths: previous
+        })
+      );
+    });
+  }, []);
+  const onResizeEndWindow = useCallback(
+    (event) => {
+      const session = resizeSessionRef.current;
+      if (!session) {
+        return;
+      }
+      if (session.pointerId !== event.pointerId) {
+        return;
+      }
+      if (event.type === "pointerup")
+        setColumnWidths(
+          (widths) => applyAdjacentSplitterResize({
+            session,
+            clientX: event.clientX,
+            widths
+          })
+        );
+      cleanupResize();
+      window.removeEventListener("pointermove", onResizeMoveWindow);
+      window.removeEventListener("pointerup", onResizeEndWindow);
+      window.removeEventListener("pointercancel", onResizeEndWindow);
+    },
+    [cleanupResize, onResizeMoveWindow]
+  );
+  useEffect(() => {
+    return () => {
+      cleanupResize();
+      window.removeEventListener("pointermove", onResizeMoveWindow);
+      window.removeEventListener("pointerup", onResizeEndWindow);
+      window.removeEventListener("pointercancel", onResizeEndWindow);
+    };
+  }, [cleanupResize, onResizeEndWindow, onResizeMoveWindow]);
+  const onResizeStart = useCallback(
+    (event, leftColumn) => {
+      if (event.pointerType === "mouse" && event.button !== 0) {
+        return;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      const rightId = getRightNeighborId(visibleColumns, leftColumn.id);
+      if (!rightId) {
+        return;
+      }
+      const leftDefinition = columnDefsById[leftColumn.id];
+      const rightDefinition = columnDefsById[rightId];
+      if (!leftDefinition || !rightDefinition) {
+        return;
+      }
+      const actualLeftWidth = getActualColumnWidth(leftColumn.id);
+      const actualRightWidth = getActualColumnWidth(rightId);
+      if (actualLeftWidth === null || actualRightWidth === null) {
+        return;
+      }
+      if (actualLeftWidth < leftDefinition.minWidth || actualRightWidth < rightDefinition.minWidth) {
+        return;
+      }
+      const session = {
+        leftId: leftColumn.id,
+        rightId,
+        pointerId: event.pointerId,
+        startClientX: event.clientX,
+        startLeftWidth: actualLeftWidth,
+        startRightWidth: actualRightWidth,
+        leftMinWidth: leftDefinition.minWidth,
+        leftMaxWidth: leftDefinition.maxWidth ?? Number.POSITIVE_INFINITY,
+        rightMinWidth: rightDefinition.minWidth,
+        rightMaxWidth: rightDefinition.maxWidth ?? Number.POSITIVE_INFINITY
+      };
+      resizeSessionRef.current = session;
+      pendingResizeSnapshotRef.current = {
+        clientX: event.clientX,
+        pointerId: event.pointerId
+      };
+      resizingColumnRef.current = leftColumn.id;
+      const leftHandle = resizeHandleRefs.current.get(leftColumn.id);
+      leftHandle?.setAttribute("data-resizing", "true");
+      window.addEventListener("pointermove", onResizeMoveWindow, {
+        passive: true
+      });
+      window.addEventListener("pointerup", onResizeEndWindow, {
+        passive: true
+      });
+      window.addEventListener("pointercancel", onResizeEndWindow, {
+        passive: true
+      });
+    },
+    [
+      columnDefsById,
+      getActualColumnWidth,
+      onResizeEndWindow,
+      onResizeMoveWindow,
+      visibleColumns
+    ]
+  );
+  const handleInputChange = useCallback(
+    (rowId, updater) => {
+      const currentRows = rowsRef.current;
+      const nextRows = currentRows.map(
+        (row) => row.id === rowId ? {
+          ...row,
+          parameter: updater(row.parameter)
+        } : row
+      );
+      commitRows(nextRows);
+    },
+    [commitRows, rows]
+  );
+  const handleDeleteSelected = useCallback(() => {
+    if (selectedIds.size === 0) {
+      return;
+    }
+    const nextRows = rows.filter((row) => !selectedIds.has(row.id));
+    setSelectedIds(/* @__PURE__ */ new Set());
+    commitRows(nextRows);
+  }, [commitRows, rows, selectedIds]);
+  const setResizeHandleRef = useCallback(
+    (columnId, node) => {
+      if (node) {
+        resizeHandleRefs.current.set(columnId, node);
+      } else {
+        resizeHandleRefs.current.delete(columnId);
+      }
+    },
+    []
+  );
+  if (rows.length === 0) {
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        className: `${ParametersTable_default.root} ${className ?? ""}`,
+        "data-sticky-header": stickyHeader,
+        style: { height },
+        children: [
+          generationError && /* @__PURE__ */ jsx(Text, { role: "alert", fontSize: "sm", p: "2", color: "var(--color-danger)", children: generationError }),
+          /* @__PURE__ */ jsx(Box, { className: ParametersTable_default.toolbar, children: /* @__PURE__ */ jsx(Box, { className: ParametersTable_default.toolbarLeft, children: /* @__PURE__ */ jsx(Text, { className: ParametersTable_default.toolbarTitle, children: "Parameters" }) }) }),
+          /* @__PURE__ */ jsx(Box, { className: ParametersTable_default.empty, children: emptyState ?? /* @__PURE__ */ jsx(Text, { children: "No parameters defined." }) })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      className: `${ParametersTable_default.root} ${className ?? ""}`,
+      "data-sticky-header": stickyHeader,
+      style: { height },
+      children: [
+        generationError && /* @__PURE__ */ jsx(Text, { role: "alert", fontSize: "sm", p: "2", color: "var(--color-danger)", children: generationError }),
+        /* @__PURE__ */ jsxs(Box, { ref: viewportRef, className: ParametersTable_default.tableViewport, children: [
+          /* @__PURE__ */ jsx(DragDropContext, { onDragEnd, children: /* @__PURE__ */ jsx(Droppable, { droppableId: "parameters", direction: "vertical", children: (provided) => /* @__PURE__ */ jsx(
+            Box,
+            {
+              ref: provided.innerRef,
+              ...provided.droppableProps,
+              className: ParametersTable_default.tableContainer,
+              children: /* @__PURE__ */ jsxs(
+                Table.Root,
+                {
+                  ref: tableRef,
+                  className: ParametersTable_default.table,
+                  stickyHeader: stickyHeader ? true : void 0,
+                  interactive: true,
+                  size: "sm",
+                  children: [
+                    /* @__PURE__ */ jsxs("colgroup", { children: [
+                      /* @__PURE__ */ jsx("col", { className: ParametersTable_default.colCheckbox }),
+                      visibleColumns.map((column) => /* @__PURE__ */ jsx(
+                        "col",
+                        {
+                          className: ParametersTable_default.colData,
+                          style: {
+                            width: columnWidths[column.id]
+                          }
+                        },
+                        column.id
+                      ))
+                    ] }),
+                    /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+                      /* @__PURE__ */ jsx(
+                        Table.ColumnHeader,
+                        {
+                          className: `${ParametersTable_default.headerCell} ${ParametersTable_default.checkboxCell}`,
+                          children: /* @__PURE__ */ jsx(Flex, { className: ParametersTable_default.checkboxCellGroup, children: /* @__PURE__ */ jsxs(
+                            Checkbox.Root,
+                            {
+                              checked: allSelected ? true : someSelected ? "indeterminate" : false,
+                              onCheckedChange: (details) => handleSelectAll(details.checked === true),
+                              size: "sm",
+                              "aria-label": "Select all parameters",
+                              className: ParametersTable_default.checkboxRoot,
+                              children: [
+                                /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                                /* @__PURE__ */ jsx(Checkbox.Control, {})
+                              ]
+                            }
+                          ) })
+                        }
+                      ),
+                      visibleColumns.map((column) => /* @__PURE__ */ jsx(
+                        Table.ColumnHeader,
+                        {
+                          "data-column": column.id,
+                          "data-sticky": column.id === "name" ? "end" : void 0,
+                          className: ParametersTable_default.headerCell,
+                          children: /* @__PURE__ */ jsxs(Box, { className: ParametersTable_default.headerContent, children: [
+                            /* @__PURE__ */ jsx(Span, { className: ParametersTable_default.headerLabel, children: column.label }),
+                            getRightNeighborId(visibleColumns, column.id) && /* @__PURE__ */ jsx(
+                              Span,
+                              {
+                                tabIndex: 0,
+                                "aria-valuenow": Math.round(
+                                  columnWidths[column.id]
+                                ),
+                                "aria-valuemin": column.minWidth,
+                                onKeyDown: (event) => {
+                                  if (event.key !== "ArrowLeft" && event.key !== "ArrowRight")
+                                    return;
+                                  event.preventDefault();
+                                  const rightId = getRightNeighborId(
+                                    visibleColumns,
+                                    column.id
+                                  );
+                                  if (!rightId) return;
+                                  const right = columnDefsById[rightId];
+                                  setColumnWidths(
+                                    (widths) => applyAdjacentSplitterResize({
+                                      widths,
+                                      clientX: (event.key === "ArrowRight" ? 1 : -1) * (event.shiftKey ? 32 : 8),
+                                      session: {
+                                        leftId: column.id,
+                                        rightId,
+                                        startClientX: 0,
+                                        startLeftWidth: widths[column.id],
+                                        startRightWidth: widths[rightId],
+                                        leftMinWidth: column.minWidth,
+                                        leftMaxWidth: column.maxWidth ?? Infinity,
+                                        rightMinWidth: right.minWidth,
+                                        rightMaxWidth: right.maxWidth ?? Infinity
+                                      }
+                                    })
+                                  );
+                                },
+                                ref: (node) => setResizeHandleRef(column.id, node),
+                                className: ParametersTable_default.resizeHandle,
+                                role: "separator",
+                                "aria-orientation": "vertical",
+                                "aria-label": `Resize ${column.label} column`,
+                                onPointerDown: (event) => onResizeStart(event, column)
+                              }
+                            )
+                          ] })
+                        },
+                        column.id
+                      ))
+                    ] }) }),
+                    /* @__PURE__ */ jsxs(Table.Body, { children: [
+                      rows.map((row, index) => {
+                        const parameter = row.parameter;
+                        const displayValue = props.values !== void 0 ? resolveParameterValue(parameter, props.document) : getDisplayValue(row, props.document);
+                        const type = resolveParameterType(
+                          parameter,
+                          props.document
+                        );
+                        const selected = selectedIds.has(row.id);
+                        return /* @__PURE__ */ jsx(
+                          Draggable,
+                          {
+                            draggableId: row.id,
+                            index,
+                            isDragDisabled: readOnly || requestMode,
+                            children: (dragProvided, snapshot) => /* @__PURE__ */ jsxs(
+                              Table.Row,
+                              {
+                                ref: dragProvided.innerRef,
+                                className: ParametersTable_default.row,
+                                "data-selected": selected,
+                                "data-dragging": snapshot.isDragging ? "true" : "false",
+                                ...dragProvided.draggableProps,
+                                children: [
+                                  /* @__PURE__ */ jsx(
+                                    Table.Cell,
+                                    {
+                                      className: `${ParametersTable_default.cell} ${ParametersTable_default.checkboxCell}`,
+                                      children: /* @__PURE__ */ jsxs(Flex, { className: ParametersTable_default.checkboxCellGroup, children: [
+                                        /* @__PURE__ */ jsx(
+                                          Box,
+                                          {
+                                            ...dragProvided.dragHandleProps,
+                                            className: ParametersTable_default.dragHandleWrap,
+                                            display: readOnly || requestMode ? "none" : void 0,
+                                            "aria-label": `Drag ${parameter.name ?? ""}`,
+                                            children: /* @__PURE__ */ jsx(RowDragHandle, {})
+                                          }
+                                        ),
+                                        /* @__PURE__ */ jsxs(
+                                          Checkbox.Root,
+                                          {
+                                            size: "sm",
+                                            checked: selected,
+                                            onCheckedChange: (details) => handleSelectRow(
+                                              row.id,
+                                              details.checked === true
+                                            ),
+                                            "aria-label": `Select ${parameter.name ?? "parameter"}`,
+                                            className: ParametersTable_default.checkboxRoot,
+                                            children: [
+                                              /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                                              /* @__PURE__ */ jsx(Checkbox.Control, {})
+                                            ]
+                                          }
+                                        )
+                                      ] })
+                                    }
+                                  ),
+                                  visibleColumns.map((column) => {
+                                    switch (column.id) {
+                                      case "name":
+                                        return /* @__PURE__ */ jsx(
+                                          Table.Cell,
+                                          {
+                                            className: `${ParametersTable_default.cell} ${ParametersTable_default.nameCell}`,
+                                            children: /* @__PURE__ */ jsxs(
+                                              Box,
+                                              {
+                                                className: ParametersTable_default.variableTextEditor,
+                                                children: [
+                                                  /* @__PURE__ */ jsx(
+                                                    VariableTextEditor,
+                                                    {
+                                                      autoFocus: false,
+                                                      ariaLabel: `Name for ${parameter.name}`,
+                                                      readOnly: readOnly || requestMode,
+                                                      value: String(parameter.name ?? ""),
+                                                      onSubmit: () => {
+                                                      },
+                                                      placeholder: "Name",
+                                                      variables: EMPTY_VARIABLES,
+                                                      allowLineBreaks: false,
+                                                      submitOnEnter: true,
+                                                      expansionMode: "overlay",
+                                                      minHeight: 28,
+                                                      safePadding: 4,
+                                                      maxFocusedHeight: 360,
+                                                      onChange: (name) => {
+                                                        handleInputChange(
+                                                          row.id,
+                                                          (p) => ({
+                                                            ...p,
+                                                            name
+                                                          })
+                                                        );
+                                                      }
+                                                    }
+                                                  ),
+                                                  /* @__PURE__ */ jsx(
+                                                    ParameterSettings,
+                                                    {
+                                                      parameter,
+                                                      document: props.document,
+                                                      disabled: readOnly || requestMode,
+                                                      onChange: (next) => handleInputChange(
+                                                        row.id,
+                                                        () => next
+                                                      )
+                                                    }
+                                                  )
+                                                ]
+                                              }
+                                            )
+                                          },
+                                          column.id
+                                        );
+                                      case "value":
+                                        return /* @__PURE__ */ jsx(
+                                          Table.Cell,
+                                          {
+                                            className: ParametersTable_default.cell,
+                                            children: /* @__PURE__ */ jsxs(
+                                              Box,
+                                              {
+                                                className: ParametersTable_default.variableTextEditor,
+                                                children: [
+                                                  requestMode && /* @__PURE__ */ jsxs(
+                                                    Checkbox.Root,
+                                                    {
+                                                      className: ParametersTable_default.checkboxRoot,
+                                                      size: "sm",
+                                                      disabled: readOnly || parameter.in === "path",
+                                                      checked: parameter.in === "path" || (effectiveValues[parameterKey(parameter)]?.enabled ?? true),
+                                                      "aria-label": `Include ${parameter.name}`,
+                                                      onCheckedChange: (event) => {
+                                                        const key = parameterKey(parameter);
+                                                        const next = {
+                                                          ...valuesRef.current,
+                                                          [key]: {
+                                                            value: valuesRef.current?.[key] ? valuesRef.current[key].value : displayValue.value,
+                                                            enabled: event.checked === true
+                                                          }
+                                                        };
+                                                        setLocalValues(next);
+                                                        onValuesChangeRef.current?.(
+                                                          next
+                                                        );
+                                                      },
+                                                      children: [
+                                                        /* @__PURE__ */ jsx(Checkbox.HiddenInput, {}),
+                                                        /* @__PURE__ */ jsx(Checkbox.Control, { children: /* @__PURE__ */ jsx(Checkbox.Indicator, {}) })
+                                                      ]
+                                                    }
+                                                  ),
+                                                  /* @__PURE__ */ jsx(
+                                                    VariableTextEditor,
+                                                    {
+                                                      autoFocus: false,
+                                                      ariaLabel: `Value for ${parameter.name}`,
+                                                      readOnly,
+                                                      value: parameterValueText(
+                                                        Object.hasOwn(
+                                                          effectiveValues,
+                                                          parameterKey(parameter)
+                                                        ) ? effectiveValues[parameterKey(parameter)].value : displayValue.value
+                                                      ),
+                                                      onSubmit: () => {
+                                                      },
+                                                      placeholder: "Value",
+                                                      variables: EMPTY_VARIABLES,
+                                                      allowLineBreaks: true,
+                                                      expansionMode: "overlay",
+                                                      minHeight: 28,
+                                                      safePadding: 4,
+                                                      maxFocusedHeight: 360,
+                                                      onChange: (value) => {
+                                                        editValue(row.id, value);
+                                                      }
+                                                    }
+                                                  )
+                                                ]
+                                              }
+                                            )
+                                          },
+                                          column.id
+                                        );
+                                      case "type":
+                                        return /* @__PURE__ */ jsx(
+                                          Table.Cell,
+                                          {
+                                            className: ParametersTable_default.cell,
+                                            children: requestMode || readOnly || parameter.content ? /* @__PURE__ */ jsx(Span, { className: ParametersTable_default.description, children: type }) : /* @__PURE__ */ jsxs(
+                                              Select.Root,
+                                              {
+                                                disabled: readOnly || requestMode,
+                                                collection: typeOptions,
+                                                size: "xs",
+                                                value: [type.split(" (")[0]],
+                                                onValueChange: (event) => {
+                                                  const newType = event.value[0];
+                                                  if (!newType) {
+                                                    return;
+                                                  }
+                                                  handleInputChange(
+                                                    row.id,
+                                                    (p) => ({
+                                                      ...p,
+                                                      schema: createSchemaForType(
+                                                        newType,
+                                                        typeof p.schema === "object" ? p.schema : void 0
+                                                      )
+                                                    })
+                                                  );
+                                                },
+                                                children: [
+                                                  /* @__PURE__ */ jsx(Select.HiddenSelect, {}),
+                                                  /* @__PURE__ */ jsxs(Select.Control, { children: [
+                                                    /* @__PURE__ */ jsx(
+                                                      Select.Trigger,
+                                                      {
+                                                        "aria-label": `Type for ${parameter.name}`,
+                                                        children: /* @__PURE__ */ jsx(
+                                                          Select.ValueText,
+                                                          {
+                                                            placeholder: type === "unknown" ? "Select type" : type
+                                                          }
+                                                        )
+                                                      }
+                                                    ),
+                                                    /* @__PURE__ */ jsx(Select.IndicatorGroup, { children: /* @__PURE__ */ jsx(Select.Indicator, {}) })
+                                                  ] }),
+                                                  /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(Select.Positioner, { children: /* @__PURE__ */ jsx(Select.Content, { className: "pdDesignerSelectMenu", children: typeOptions.items.map(
+                                                    (item) => /* @__PURE__ */ jsxs(
+                                                      Select.Item,
+                                                      {
+                                                        item,
+                                                        children: [
+                                                          item.label,
+                                                          /* @__PURE__ */ jsx(Select.ItemIndicator, {})
+                                                        ]
+                                                      },
+                                                      item.value
+                                                    )
+                                                  ) }) }) })
+                                                ]
+                                              }
+                                            )
+                                          },
+                                          column.id
+                                        );
+                                      case "required":
+                                        return /* @__PURE__ */ jsx(
+                                          Table.Cell,
+                                          {
+                                            className: ParametersTable_default.cell,
+                                            children: /* @__PURE__ */ jsx(
+                                              Span,
+                                              {
+                                                className: parameter.in === "path" || parameter.required ? ParametersTable_default.required : ParametersTable_default.optional,
+                                                children: parameter.in === "path" || parameter.required ? "Required" : "Optional"
+                                              }
+                                            )
+                                          },
+                                          column.id
+                                        );
+                                      case "description":
+                                        return /* @__PURE__ */ jsx(
+                                          Table.Cell,
+                                          {
+                                            className: ParametersTable_default.cell,
+                                            children: /* @__PURE__ */ jsx(Span, { className: ParametersTable_default.description, children: parameter.description ?? "\u2014" })
+                                          },
+                                          column.id
+                                        );
+                                      default:
+                                        return null;
+                                    }
+                                  })
+                                ]
+                              }
+                            )
+                          },
+                          row.id
+                        );
+                      }),
+                      provided.placeholder
+                    ] })
+                  ]
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx(ActionBar.Root, { open: selectedIds.size > 0, children: /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(ActionBar.Positioner, { children: /* @__PURE__ */ jsxs(ActionBar.Content, { className: ParametersTable_default.actionBarContent, children: [
+            /* @__PURE__ */ jsx(Box, { className: ParametersTable_default.actionBarLeft, children: /* @__PURE__ */ jsxs(
+              ActionBar.SelectionTrigger,
+              {
+                className: ParametersTable_default.actionBarTrigger,
+                children: [
+                  selectedIds.size,
+                  " selected"
+                ]
+              }
+            ) }),
+            /* @__PURE__ */ jsx(Span, { className: ParametersTable_default.actionBarDivider }),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "ghost",
+                size: "xs",
+                className: ParametersTable_default.actionButton,
+                disabled: readOnly || requestMode,
+                onClick: handleDeleteSelected,
+                children: [
+                  /* @__PURE__ */ jsx(AiOutlineDelete, { className: ParametersTable_default.actionIcon }),
+                  "Delete"
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx(Span, { className: ParametersTable_default.actionBarDivider }),
+            /* @__PURE__ */ jsxs(
+              Button,
+              {
+                variant: "ghost",
+                size: "xs",
+                className: `${ParametersTable_default.actionButton} ${ParametersTable_default.actionButtonAccent}`,
+                disabled: readOnly,
+                onClick: handleGenerate,
+                children: [
+                  /* @__PURE__ */ jsx(LuRefreshCw, { className: ParametersTable_default.actionIcon }),
+                  "Generate values"
+                ]
+              }
+            )
+          ] }) }) }) })
+        ] })
+      ]
+    }
+  );
+});
+
+export { DEFAULT_COLUMNS, ParameterTable, applyAdjacentSplitterResize, areParameterArraysEqual, areParametersEqual, buildColumnDefsById, clamp, createRows, fitColumnWidths, getDisplayValue, getRightNeighborId, getVisibleColumns, reconcileRows, reorder };