@cratis/event-models 0.338.0 → 0.339.1

package/dist/screen-editor/HookEditors-vV4ycK6R.js

@@ -0,0 +1,37 @@
+import { n as p, t as k } from "./HookOpensField-Ja5uMCr8.js";
+import { jsx as i } from "react/jsx-runtime";
+import { Opens as s } from "@cratis/scene.model";
+var b = ({ value: o, onChange: t, context: e, disabled: n }) => /* @__PURE__ */ i(k, {
+  hook: {
+    ...o?.hook,
+    ...l(o?.value)
+  },
+  environment: e.lookups.placement,
+  strings: e.strings.editors.placement,
+  disabled: n,
+  onChange: (r) => t({
+    value: r,
+    hook: o?.hook ?? {}
+  })
+}), l = (o) => o === void 0 || o === s.Automatic ? {} : o.startsWith(s.Slot) ? {
+  opens: s.Slot,
+  ...o.length > 5 ? { opensIn: o.slice(5) } : {}
+} : { opens: o }, h = ({ value: o, onChange: t, context: e, disabled: n }) => /* @__PURE__ */ i(p, {
+  hook: o?.hook ?? {},
+  environment: e.lookups.placement,
+  strings: e.strings.editors.placement,
+  disabled: n,
+  ...o?.outletSubject ? { outletSubject: o.outletSubject } : {},
+  value: {
+    ...o?.subject ? { subject: o.subject } : {},
+    ...o?.enabledWhen ? { enabledWhen: o.enabledWhen } : {}
+  },
+  onChange: (r) => t({
+    ...r,
+    hook: o?.hook ?? {}
+  })
+});
+export {
+  h as HookEnabledEditor,
+  b as HookOpensEditor
+};

package/dist/screen-editor/HookOpensField-Ja5uMCr8.js

@@ -0,0 +1,231 @@
+import { a as C, s as j } from "./hookBinding-DOpu2dMp.js";
+import { useEffect as y, useState as F } from "react";
+import { jsx as o, jsxs as p } from "react/jsx-runtime";
+import { Opens as t, OutletSubject as S } from "@cratis/scene.model";
+import { EnablementOutcome as O, parseGuardCondition as w } from "@cratis/scene.engine";
+var P = ({ hook: i, environment: l, strings: a, disabled: c, outletSubject: r, value: d, onChange: u }) => {
+  const v = d.subject ?? "", h = d.enabledWhen ?? "", [s, _] = F(h), f = s.trim() === "" || w(s) !== void 0;
+  y(() => _(h), [h]);
+  const e = () => {
+    f && s.trim() !== h.trim() && u({
+      ...d,
+      enabledWhen: s
+    });
+  }, m = {
+    ...i,
+    subject: d.subject ?? r ?? S.Screen,
+    ...f && s.trim() !== "" ? { enabledWhen: s } : {}
+  }, b = j(m, l ?? {
+    slices: [],
+    slots: [],
+    itemFields: /* @__PURE__ */ new Set(),
+    routeParameters: []
+  }).enablement.steps;
+  return /* @__PURE__ */ p("div", {
+    className: "studio-placement",
+    "data-field": "enabled",
+    children: [
+      /* @__PURE__ */ p("label", {
+        className: "studio-placement__field",
+        children: [/* @__PURE__ */ o("span", { children: a.actsOn }), /* @__PURE__ */ o("select", {
+          value: v,
+          disabled: c,
+          onChange: (n) => u({
+            ...d,
+            ...n.target.value === "" ? { subject: void 0 } : { subject: n.target.value }
+          }),
+          children: [
+            "",
+            S.Item,
+            S.Screen
+          ].map((n) => /* @__PURE__ */ o("option", {
+            value: n,
+            children: a.actsOnChoices[n]
+          }, n))
+        })]
+      }),
+      /* @__PURE__ */ p("label", {
+        className: "studio-placement__field",
+        children: [/* @__PURE__ */ o("span", { children: a.condition }), /* @__PURE__ */ o("input", {
+          value: s,
+          disabled: c,
+          placeholder: a.conditionPlaceholder,
+          "aria-invalid": !f || void 0,
+          onChange: (n) => _(n.target.value),
+          onBlur: e,
+          onKeyDown: (n) => {
+            n.key === "Enter" && (n.preventDefault(), e());
+          }
+        })]
+      }),
+      /* @__PURE__ */ o("p", {
+        className: "studio-placement__note",
+        children: f ? a.conditionHint : a.conditionUnreadable
+      }),
+      /* @__PURE__ */ o("p", {
+        className: "studio-placement__heading",
+        children: a.derivedFrom
+      }),
+      /* @__PURE__ */ p("ul", {
+        className: "studio-placement__steps",
+        "aria-label": a.derivedFrom,
+        children: [b.length === 0 && /* @__PURE__ */ o("li", {
+          "data-outcome": "passed",
+          children: a.alwaysEnabled
+        }), b.map((n) => /* @__PURE__ */ p("li", {
+          "data-outcome": n.outcome,
+          "data-blocked": n.outcome === O.Blocked || void 0,
+          children: [
+            /* @__PURE__ */ o("strong", { children: a.steps[n.check] }),
+            " ",
+            n.reason
+          ]
+        }, n.check))]
+      })
+    ]
+  });
+}, k = [
+  t.Automatic,
+  t.None,
+  t.Dialog,
+  t.Drawer,
+  t.Slot
+], x = (i) => [
+  "…",
+  ...i.parameters.map((l) => l.value ?? `:${l.name}`),
+  i.segment
+].join("/"), A = (i) => {
+  const { opensIn: l, ...a } = i;
+  return a;
+}, D = (i, l, a) => j({
+  ...a === t.Slot ? i : A(i),
+  opens: a
+}, l).placement;
+function E(i, l) {
+  const a = j(i, l), c = a.placement;
+  return c ? {
+    inspection: a,
+    decision: c,
+    options: k.map((r) => {
+      if (r === t.Automatic) return {
+        value: r,
+        available: !0,
+        reason: D(i, l, t.Automatic).reason
+      };
+      if (r === t.None) return {
+        value: r,
+        available: c.runDirectly.available,
+        reason: c.runDirectly.reason
+      };
+      if (r === t.Slot) {
+        const u = c.slots.filter((v) => v.offered);
+        return {
+          value: r,
+          available: u.length > 0,
+          reason: u.length > 0 ? "" : c.slots[0]?.reason ?? ""
+        };
+      }
+      const d = D(i, l, r);
+      return {
+        value: r,
+        available: d.resolved !== void 0,
+        reason: d.reason
+      };
+    }),
+    slots: c.slots
+  } : {
+    inspection: a,
+    options: [],
+    slots: []
+  };
+}
+var H = [
+  t.Automatic,
+  t.None,
+  t.Dialog,
+  t.Drawer,
+  t.Slot
+], G = ({ hook: i, environment: l, strings: a, disabled: c, onChange: r }) => {
+  if (!l) return null;
+  if (!i.slice) return /* @__PURE__ */ o("p", {
+    className: "studio-placement__note",
+    children: a.chooseSlice
+  });
+  const { inspection: d, decision: u, options: v, slots: h } = E(i, l);
+  if (!u) return /* @__PURE__ */ o("p", {
+    className: "studio-placement__note",
+    children: a.chooseSlice
+  });
+  const s = C(i.opens, i.opensIn), _ = (e) => e === t.Slot ? s.startsWith("slot") : s === e, f = (e, m) => {
+    !c && m && r(e);
+  };
+  return /* @__PURE__ */ p("div", {
+    className: "studio-placement",
+    "data-field": "opens",
+    children: [
+      d.screenless && /* @__PURE__ */ o("p", {
+        className: "studio-placement__note",
+        "data-screenless": "",
+        children: a.screenless
+      }),
+      /* @__PURE__ */ o("div", {
+        role: "radiogroup",
+        "aria-label": a.opens,
+        className: "studio-placement__choices",
+        children: H.map((e) => {
+          const m = v.find((N) => N.value === e);
+          if (!m) return null;
+          const b = a.choices[e], n = !m.available;
+          return /* @__PURE__ */ o("div", {
+            className: "studio-placement__choice",
+            "data-chosen": _(e) || void 0,
+            "data-unavailable": n || void 0,
+            children: /* @__PURE__ */ p("button", {
+              type: "button",
+              role: "radio",
+              "aria-checked": _(e),
+              "aria-disabled": n || c || void 0,
+              "data-opens": e,
+              title: n ? m.reason : b.hint,
+              onClick: () => f(e === t.Slot ? C(t.Slot, h.find((N) => N.offered)?.name) : e, m.available),
+              children: [/* @__PURE__ */ o("strong", { children: b.label }), /* @__PURE__ */ o("span", { children: e === t.Slot && !n ? b.hint : m.reason || b.hint })]
+            })
+          }, e);
+        })
+      }),
+      _(t.Automatic) && /* @__PURE__ */ o("p", {
+        className: "studio-placement__resolved",
+        "data-resolved": "",
+        children: u.reason
+      }),
+      !d.screenless && /* @__PURE__ */ p("ul", {
+        className: "studio-placement__slots",
+        "aria-label": a.slotsHeading,
+        children: [h.length === 0 && /* @__PURE__ */ o("li", {
+          className: "studio-placement__note",
+          children: a.noSlots
+        }), h.map((e) => /* @__PURE__ */ o("li", {
+          "data-unavailable": !e.offered || void 0,
+          "data-chosen": s === `slot:${e.name}` || void 0,
+          children: /* @__PURE__ */ p("button", {
+            type: "button",
+            "aria-pressed": s === `slot:${e.name}`,
+            "aria-disabled": !e.offered || c || void 0,
+            "data-slot": e.name,
+            title: e.reason,
+            onClick: () => f(`slot:${e.name}`, e.offered),
+            children: [
+              /* @__PURE__ */ o("strong", { children: e.name }),
+              /* @__PURE__ */ o("span", { children: a.slotKind(e.role, e.routed) }),
+              /* @__PURE__ */ o("em", { children: e.offered && e.route ? a.slotRoute(x(e.route)) : e.reason })
+            ]
+          })
+        }, e.name))]
+      })
+    ]
+  });
+};
+export {
+  P as n,
+  G as t
+};

package/dist/screen-editor/QueryBindingPropertyEditor-QpvyESab.js

@@ -0,0 +1,148 @@
+import { L as N, R as E, c as B, d as L, f as F, h as I, l as j, m as M, t as R, u as Q } from "./DataBindingSections-DGWtMxlD.js";
+import { useState as k } from "react";
+import { Fragment as S, jsx as o, jsxs as d } from "react/jsx-runtime";
+import { validateBinding as D } from "@cratis/scene.engine";
+var c = /* @__PURE__ */ (function(r) {
+  return r.NoQuery = "noQuery", r.MissingQuery = "missingQuery", r.Loading = "loading", r.Empty = "empty", r.Error = "error", r.Ready = "ready", r;
+})({});
+function O({ binding: r, candidate: i, isLoading: u, error: l, rowCount: s }) {
+  return r ? i ? l != null ? c.Error : u ? c.Loading : s === 0 ? c.Empty : c.Ready : c.MissingQuery : c.NoQuery;
+}
+function b(r, i, u, l) {
+  const s = D(r, i, u, l);
+  return {
+    diagnostics: s,
+    isStorable: s.every((m) => m.severity !== "error")
+  };
+}
+var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, candidates: i, scope: u, strings: l, disabled: s, onChange: m }) => {
+  const t = l.properties.query, [g, y] = k(), h = Q(r.effectiveValue) ? r.effectiveValue : void 0, n = g ?? h, p = n ? i.find((e) => e.id === n.queryId) : void 0, _ = n ? b(r.descriptor, p, n, u).diagnostics : [], v = (e) => {
+    if (!e) {
+      y(void 0), m(void 0);
+      return;
+    }
+    const a = b(r.descriptor, i.find((f) => f.id === e.queryId), e, u);
+    y(a.isStorable ? void 0 : e), a.isStorable && m(e);
+  }, q = O({
+    binding: n,
+    candidate: p,
+    isLoading: !1
+  }), C = Object.keys(u.types);
+  return /* @__PURE__ */ d("fieldset", {
+    className: "studio-editor-query",
+    disabled: s,
+    children: [
+      /* @__PURE__ */ o("legend", { children: r.descriptor.label }),
+      /* @__PURE__ */ d("label", { children: [/* @__PURE__ */ o("span", { children: t.label }), /* @__PURE__ */ d("select", {
+        value: n?.queryId ?? "",
+        onChange: (e) => {
+          const a = i.find((f) => f.id === e.target.value);
+          v(a ? B(a) : void 0);
+        },
+        children: [
+          /* @__PURE__ */ o("option", {
+            value: "",
+            children: t.none
+          }),
+          n && !p && /* @__PURE__ */ o("option", {
+            value: n.queryId,
+            children: n.query
+          }),
+          i.map((e) => /* @__PURE__ */ d("option", {
+            value: e.id,
+            children: [
+              e.name,
+              " - ",
+              V(e)
+            ]
+          }, e.id))
+        ]
+      })] }),
+      n && !p && /* @__PURE__ */ o("p", {
+        className: "studio-editor-query__missing",
+        role: "alert",
+        children: t.missing
+      }),
+      n && p && /* @__PURE__ */ d(S, { children: [p.parameters.length > 0 && /* @__PURE__ */ d("div", {
+        className: "studio-editor-query__group",
+        children: [/* @__PURE__ */ o("strong", { children: t.parameters }), p.parameters.map((e) => /* @__PURE__ */ d("label", { children: [/* @__PURE__ */ d("span", { children: [t.sourceFor(e.name), e.required ? " *" : ""] }), /* @__PURE__ */ d("select", {
+          value: M(n, e),
+          onChange: (a) => v(F(n, e.name, a.target.value)),
+          children: [/* @__PURE__ */ o("option", {
+            value: "",
+            children: t.noSource
+          }), C.map((a) => /* @__PURE__ */ o("option", {
+            value: a,
+            children: a
+          }, a))]
+        })] }, e.name))]
+      }), /* @__PURE__ */ d("div", {
+        className: "studio-editor-query__group",
+        children: [/* @__PURE__ */ o("strong", { children: t.columns }), p.resultFields.map((e) => /* @__PURE__ */ d("label", {
+          className: "studio-editor-query__column",
+          children: [/* @__PURE__ */ o("input", {
+            type: "checkbox",
+            checked: j(n, e),
+            onChange: (a) => v(a.target.checked ? L(n, e.name) : I(n, e.name))
+          }), /* @__PURE__ */ o("span", { children: t.showColumn(e.name) })]
+        }, e.name))]
+      })] }),
+      /* @__PURE__ */ o("p", {
+        className: "studio-editor-query__preview",
+        role: "status",
+        "data-state": q,
+        children: $(q, t.preview)
+      }),
+      /* @__PURE__ */ o(N, {
+        diagnostics: _,
+        label: l.properties.diagnostics
+      })
+    ]
+  });
+};
+function $(r, i) {
+  switch (r) {
+    case c.NoQuery:
+      return i.noQuery;
+    case c.MissingQuery:
+      return i.missingQuery;
+    case c.Loading:
+      return i.loading;
+    case c.Empty:
+      return i.empty;
+    case c.Error:
+      return i.error;
+    case c.Ready:
+      return i.ready;
+  }
+}
+var J = ({ value: r, onChange: i, context: u, disabled: l }) => {
+  const { session: s } = u;
+  if (!s) return null;
+  const m = Q(r) ? r : void 0, t = m ? u.lookups.queryCandidates.find((g) => g.id === m.queryId) : void 0;
+  return /* @__PURE__ */ d(S, { children: [/* @__PURE__ */ o(T, {
+    property: s.property,
+    candidates: u.lookups.queryCandidates,
+    scope: s.bindingScope,
+    strings: s.screenStrings,
+    disabled: l === !0,
+    onChange: i
+  }), m && t && /* @__PURE__ */ o(R, {
+    controller: s.controller,
+    environment: s.environment,
+    strings: s.screenStrings,
+    binding: m,
+    candidate: t,
+    disabled: l === !0,
+    onChange: (g, y, h) => {
+      const n = h === "" ? s.bindingScope : E({
+        ...s.bindingScope.types,
+        [h]: y.type
+      });
+      b(s.property.descriptor, t, g, n).isStorable && i(g);
+    }
+  })] });
+};
+export {
+  J as QueryBindingPropertyEditor
+};

package/dist/screen-editor/ScreenEditor/Actions/ActionModel.d.ts

@@ -1,8 +1,10 @@
-import type { Opens } from '@cratis/scene.model';
+import type { Opens, OutletSubject } from '@cratis/scene.model';
 export interface ActionModel {
     sliceId: string;
     sliceName: string;
     inputs: Record<string, string>;
     opens: Opens;
     opensIn?: string;
+    subject?: OutletSubject;
+    enabledWhen?: string;
 }

package/dist/screen-editor/ScreenEditor/Actions/StateChangeSlice.d.ts

@@ -1,3 +1,4 @@
+import type { ScreenFit } from '@cratis/scene.model';
 export interface StateChangeSlice {
     id: string;
     name: string;
@@ -8,6 +9,9 @@ export interface StateChangeSlice {
         type: string;
         required: boolean;
     }[];
+    screenless?: boolean;
+    fits?: ScreenFit[];
+    authorize?: string;
 }
 export declare const commandNameOf: (slice: StateChangeSlice) => string;
 export declare function sliceNamedBy(slices: readonly StateChangeSlice[], command: unknown): StateChangeSlice | undefined;

package/dist/screen-editor/ScreenEditor/Actions/actionBehavior.d.ts

@@ -3,7 +3,9 @@ import type { ActionModel } from './ActionModel';
 export declare const actionComponentName = "action";
 export declare const opensProperty = "opens";
 export declare const opensInProperty = "opensIn";
+export declare const subjectProperty = "subject";
+export declare const enabledWhenProperty = "enabledWhen";
 export declare const argumentsProperty = "arguments";
 export declare function readActionModel(properties: Record<string, unknown> | undefined, sliceName?: string): ActionModel | undefined;
 export declare function toActionProperties(model: ActionModel): Record<string, unknown>;
-export declare function actionEdits(componentId: string, model: ActionModel): SceneEdit[];
+export declare function actionEdits(componentId: string, model: ActionModel, current?: Record<string, unknown>): SceneEdit[];

package/dist/screen-editor/ScreenEditor/Binding/detailShows.d.ts

@@ -0,0 +1,18 @@
+import type { Layout, SceneDocument } from '@cratis/scene.model';
+import type { ScreenTemplate } from '@cratis/scene.model';
+export interface DetailShow {
+    slot: string;
+    screen: string;
+    by: string;
+    element: string;
+}
+export declare const showText: (show: Omit<DetailShow, 'slot'>) => string;
+export declare function screenplayNameOf(elementId: string): string;
+export declare function detailShowsOf(document: SceneDocument): DetailShow[];
+export declare function withDetailShow(document: SceneDocument, slot: string, show: Omit<DetailShow, 'slot'> | undefined): SceneDocument;
+export interface RoutedSlot {
+    name: string;
+    routedBy: readonly string[];
+}
+export declare const hasRoutedSlot: (document: SceneDocument, templates: readonly ScreenTemplate[], layouts: readonly Layout[]) => boolean;
+export declare function routedSlotsOf(document: SceneDocument, templates: readonly ScreenTemplate[], layouts: readonly Layout[]): RoutedSlot[];

package/dist/screen-editor/ScreenEditor/Binding/parameterFeeds.d.ts

@@ -0,0 +1,22 @@
+import { type OutletFilter, type QueryBinding, type Slot } from '@cratis/scene.model';
+export interface FilterFeed {
+    outlet: string;
+    id: string;
+    title: string;
+}
+export interface ListedItem {
+    id: string;
+    label: string;
+    values: Record<string, unknown>;
+}
+export declare function filtersSetting(outlet: string, items: readonly ListedItem[], query: string, parameter: string): FilterFeed[];
+export declare const filtersSettingQuery: (items: readonly ListedItem[], query: string) => ListedItem[];
+export declare function filterFor(query: string, parameter: string, id: string): OutletFilter;
+export interface RoutedValue {
+    slot: string;
+    parameter: string;
+    path: string;
+}
+export declare function routedValuesOf(slots: readonly Slot[]): RoutedValue[];
+export declare const mappedRouteOf: (binding: QueryBinding, parameter: string, values: readonly RoutedValue[]) => RoutedValue | undefined;
+export declare const withRouteSource: (binding: QueryBinding, parameter: string, value: RoutedValue | undefined) => QueryBinding;

package/dist/screen-editor/ScreenEditor/Binding/queryBindingModel.d.ts

@@ -3,6 +3,7 @@ export declare function bindToCandidate(candidate: QueryCandidate): QueryBinding
 export declare function isQueryBinding(value: unknown): value is QueryBinding;
 export declare function mapParameter(binding: QueryBinding, parameter: string, sourcePath: string): QueryBinding;
 export declare function mapColumn(binding: QueryBinding, field: string, target?: string): QueryBinding;
+export declare function placeColumn(binding: QueryBinding, field: string, index: number | undefined, target?: string): QueryBinding;
 export declare function unmapColumn(binding: QueryBinding, field: string): QueryBinding;
 export declare const sourceOf: (binding: QueryBinding, parameter: QueryParameter) => string;
 export declare const isColumnShown: (binding: QueryBinding, field: QueryResultField) => boolean;

package/dist/screen-editor/ScreenEditor/Data/DataField.d.ts

@@ -0,0 +1,39 @@
+import { type QueryCandidate } from '@cratis/scene.model';
+import { type StateChangeSlice } from '../Actions/StateChangeSlice';
+export interface CommandDataField {
+    source: 'command';
+    sliceId: string;
+    command: string;
+    property: string;
+    type: string;
+}
+export interface QueryDataField {
+    source: 'query';
+    queryId: string;
+    query: string;
+    field: string;
+    type: string;
+}
+export interface QueryResultDataField {
+    source: 'queryResult';
+    queryId: string;
+    query: string;
+    shape: 'collection' | 'single' | 'optional-single';
+}
+export type DataField = CommandDataField | QueryDataField | QueryResultDataField;
+export interface ScreenData {
+    command?: {
+        name: string;
+        fields: readonly CommandDataField[];
+    };
+    queries: readonly {
+        id: string;
+        name: string;
+        shape: QueryResultDataField['shape'];
+        fields: readonly QueryDataField[];
+    }[];
+}
+export declare const dataFieldKey: (field: DataField) => string;
+export declare const dataFieldLabel: (field: DataField) => string;
+export declare function screenDataOf(sliceId: string | undefined, slices: readonly StateChangeSlice[], candidates: readonly QueryCandidate[]): ScreenData;
+export declare const isDataField: (value: unknown) => value is DataField;

package/dist/screen-editor/ScreenEditor/Data/insertDataField.d.ts

@@ -0,0 +1,29 @@
+import { type QueryCandidate } from '@cratis/scene.model';
+import type { PackageCatalog } from '@cratis/scene.engine';
+import { type StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { CanvasPlacement } from '../Document/placeOnCanvas';
+import type { TableDrop } from '../Surface/columnAt';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { DataField, QueryDataField } from './DataField';
+export declare const singleResultComponentName = "singleResult";
+export declare const initialTableColumns = 4;
+export declare const initialSummaryFields = 6;
+export interface DataFieldTarget {
+    parentId: string | undefined;
+    index: number | undefined;
+    at?: CanvasPlacement;
+    over?: TableDrop;
+}
+export interface DataFieldInsertion {
+    controller: Pick<ScreenEditorController, 'document' | 'composition' | 'insertElement' | 'setScreenForms' | 'select' | 'apply'>;
+    packages: PackageCatalog;
+    stateChangeSlices: readonly StateChangeSlice[];
+    queryCandidates: readonly QueryCandidate[];
+    bindsQuery: (componentName: string) => boolean;
+    newId: () => string;
+}
+export type DataFieldRefusal = 'unknownCommand' | 'unknownQuery' | 'noCommandForm' | 'noSingleResult' | 'noTable';
+export declare function componentNamed(packages: PackageCatalog, component: string): string | undefined;
+export declare function insertDataField(field: DataField, target: DataFieldTarget, insertion: DataFieldInsertion): DataFieldRefusal | undefined;
+export declare function generateForm(sliceId: string, target: DataFieldTarget, insertion: DataFieldInsertion): DataFieldRefusal | undefined;
+export declare function removeQueryColumn(field: QueryDataField, { controller }: Pick<DataFieldInsertion, 'controller'>): void;

package/dist/screen-editor/ScreenEditor/Data/queryTables.d.ts

@@ -0,0 +1,10 @@
+import { type QueryBinding, type SceneEdit, type SceneElement } from '@cratis/scene.model';
+export declare const tableComponentNames: string[];
+export declare const queryProperty = "query";
+export interface QueryTable {
+    elementId: string;
+    binding: QueryBinding;
+}
+export declare function queryTableOf(element: SceneElement): QueryTable | undefined;
+export declare function queryTablesOf(roots: readonly SceneElement[]): QueryTable[];
+export declare const bindingEdit: (elementId: string, binding: QueryBinding) => SceneEdit;

package/dist/screen-editor/ScreenEditor/DesignMode/DesignModeFrames.d.ts

@@ -1,9 +1,11 @@
 import { type RefObject } from 'react';
 import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenOutlets } from './Outlets/screenOutlets';
 import type { DesignModeStrings } from './DesignModeStrings';
 export interface DesignModeFramesProps {
     surface: RefObject<HTMLDivElement | null>;
     controller: ScreenEditorController;
     strings: DesignModeStrings;
+    outlets?: ScreenOutlets;
 }
-export declare const DesignModeFrames: ({ surface, controller, strings }: DesignModeFramesProps) => import("react").JSX.Element;
+export declare const DesignModeFrames: ({ surface, controller, strings, outlets }: DesignModeFramesProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/DesignMode/DesignModeStrings.d.ts

@@ -1,3 +1,4 @@
+import { type OutletStrings } from './Outlets/OutletStrings';
 export interface DesignModeStrings {
     toolbarLabel: (itemLabel: string) => string;
     slotName: (slot: string) => string;
@@ -68,6 +69,7 @@ export interface DesignModeStrings {
         };
         problems: Record<string, string>;
     };
+    outlets: OutletStrings;
     announce: {
         added: (label: string) => string;
         moved: (label: string, position: number, of: number) => string;