@burdenoff/microfe-bigconsole 2026.1012.3 → 2026.1012.5

package/dist/bigconsole/utils/layoutBaseline.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Dashboard layout baseline (BOFF-8060, N3/N4: the dashboard leave guard).
+ *
+ * The dashboard builder keeps moved and resized widgets only in the widget store
+ * until the toolbar Save runs (`DashboardBuilderPage.handleSave`, step 2). To tell
+ * the assistant "this editor holds unsaved work" the builder needs one honest
+ * boolean, and the store has none: `widgetStore.dirtyWidgetIds` is never marked and
+ * `dashboardStore.hasUnsavedChanges` is never cleared. This module is that boolean,
+ * as plain functions with no React, so it can be tested without a DOM.
+ *
+ * ★★ "A layout event happened" is NOT a dirty signal. Positions reach the store on
+ * load (`setWidgets`), when a widget is created or deleted, and when a save writes
+ * its own positions back, none of which is the person's work. Only a PERSON'S
+ * placement is. So the baseline FLOATS (it is re-taken on every observation)
+ * until the first placement by a person, and from then on it is FROZEN: it holds
+ * the last layout the server is known to have, and "dirty" means the current
+ * layout differs from it BY VALUE:
+ *
+ *   load / refetch / add / delete / save write-back  -> baseline follows, clean
+ *   first drag, resize, or typed placement           -> baseline freezes
+ *   a drag that moves and moves back                 -> equal again, clean
+ *   a successful save                                -> baseline = what was saved
+ *   a failed save                                    -> nothing happens, still dirty
+ *
+ * ★★ The "placement by a person" signal is `layoutEditRevision` on the widget
+ * store, a counter bumped by `updateWidgetPosition` and by nothing else. It is the
+ * ONE writer shared by the canvas (drag stop, resize stop) and the inspector's
+ * "Position & size" fields, so a placement typed into the inspector, which never
+ * touches the grid, freezes the baseline too. A signal taken from the grid alone
+ * would let a floating baseline silently absorb it.
+ *
+ * Every function here is pure. `useDashboardLayoutBaseline` is the React shell.
+ */
+/** One widget's grid cell, in grid units (columns / rows). */
+export interface LayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+export interface LayoutItem extends LayoutRect {
+    readonly id: string;
+}
+/**
+ * Widget id -> cell, keys in sorted order. A `Map` (not a plain object) so an
+ * id such as `"1"` or `"__proto__"` is only ever a key.
+ */
+export type NormalisedLayout = ReadonlyMap<string, LayoutRect>;
+interface PositionLike {
+    readonly x?: number | null;
+    readonly y?: number | null;
+    readonly width?: number | null;
+    readonly height?: number | null;
+}
+/**
+ * What a widget must carry for its cell to be read. Structural, so the store's
+ * `Widget` satisfies it and a test can pass a plain object.
+ */
+export interface LayoutSourceWidget {
+    readonly id: string;
+    readonly position?: PositionLike | null;
+    readonly positionX?: number | null;
+    readonly positionY?: number | null;
+    readonly positionWidth?: number | null;
+    readonly positionHeight?: number | null;
+}
+/**
+ * The cell a widget with no stored size falls back to. These mirror
+ * `DashboardGrid.widgetToLayout` exactly, so the baseline reads a widget the same
+ * way the grid draws it.
+ */
+export declare const DEFAULT_LAYOUT_CELL: LayoutRect;
+/**
+ * Items -> a sorted `id -> x,y,w,h` map. Order of the input does not matter, a
+ * repeated id keeps the last one, and a non-finite number becomes 0 so a stray
+ * `NaN` (which is never equal to itself) cannot make a layout permanently dirty.
+ */
+export declare function normaliseLayout(items: Iterable<LayoutItem>): NormalisedLayout;
+/** The widget store's widgets -> a normalised layout (every widget in the store, which is what Save sends). */
+export declare function layoutFromWidgets(widgets: Iterable<LayoutSourceWidget>): NormalisedLayout;
+/** The `{ id, position }` list `batchUpdatePositions` sends -> layout items (exactly what reached the server). */
+export declare function layoutItemsFromPositionUpdates(updates: ReadonlyArray<{
+    readonly id: string;
+    readonly position: PositionLike;
+}>): LayoutItem[];
+/** Same widgets in the same cells (by value; key order and object identity are irrelevant). */
+export declare function layoutEquals(a: NormalisedLayout, b: NormalisedLayout): boolean;
+/**
+ * Does `current` differ from `baseline`? Different cells, a widget present on only
+ * one side, or both, all count. With no baseline there is nothing to differ from,
+ * so the answer is no: this never claims unsaved work it cannot point to.
+ */
+export declare function layoutDirty(current: NormalisedLayout, baseline: NormalisedLayout | null): boolean;
+export interface LayoutBaselineState {
+    /** The layout the server is known to hold, or the last loaded one while floating. `null` until first observed. */
+    readonly baseline: NormalisedLayout | null;
+    /** True once a person has placed something since the baseline was taken. Frozen baselines do not follow the store. */
+    readonly frozen: boolean;
+    /** The last `layoutEditRevision` seen, to notice the next placement. `null` until first observed. */
+    readonly seenRevision: number | null;
+}
+export declare const INITIAL_LAYOUT_BASELINE: LayoutBaselineState;
+export type LayoutBaselineAction = 
+/** The store changed (or the page mounted): here is the layout and the placement counter now. */
+{
+    readonly type: 'observe';
+    readonly layout: NormalisedLayout;
+    readonly editRevision: number;
+}
+/**
+ * The positions reached the server. `layout` is exactly what was sent;
+ * `editRevision` is the counter read BEFORE the request started, so a
+ * placement made while it was in flight is not mistaken for saved.
+ */
+ | {
+    readonly type: 'saved';
+    readonly layout: NormalisedLayout;
+    readonly editRevision: number;
+}
+/** A different dashboard: forget everything. */
+ | {
+    readonly type: 'reset';
+};
+export declare function reduceLayoutBaseline(state: LayoutBaselineState, action: LayoutBaselineAction): LayoutBaselineState;
+/**
+ * The one boolean the builder reports. A floating baseline is never dirty by
+ * definition: it follows the store, so whatever differs is not the person's work.
+ */
+export declare function isLayoutBaselineDirty(state: LayoutBaselineState, current: NormalisedLayout): boolean;
+export {};

package/dist/bigconsole/utils/layoutBaseline.js

@@ -0,0 +1,96 @@
+//#region src/bigconsole/utils/layoutBaseline.ts
+var e = {
+	x: 0,
+	y: 0,
+	w: 4,
+	h: 4
+}, t = (e) => typeof e == "number" && Number.isFinite(e) ? e : void 0, n = (e) => Number.isFinite(e) ? e : 0;
+function r(e, n, r) {
+	return t(e) ?? t(n) ?? r;
+}
+var i = (e, t) => e < t ? -1 : +(e > t);
+function a(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let r of e) t.set(r.id, {
+		x: n(r.x),
+		y: n(r.y),
+		w: n(r.w),
+		h: n(r.h)
+	});
+	return new Map([...t.entries()].sort(([e], [t]) => i(e, t)));
+}
+function o(t) {
+	let n = [];
+	for (let i of t) n.push({
+		id: i.id,
+		x: r(i.position?.x, i.positionX, e.x),
+		y: r(i.position?.y, i.positionY, e.y),
+		w: r(i.position?.width, i.positionWidth, e.w),
+		h: r(i.position?.height, i.positionHeight, e.h)
+	});
+	return a(n);
+}
+function s(t) {
+	return t.map((t) => ({
+		id: t.id,
+		x: r(t.position.x, void 0, e.x),
+		y: r(t.position.y, void 0, e.y),
+		w: r(t.position.width, void 0, e.w),
+		h: r(t.position.height, void 0, e.h)
+	}));
+}
+function c(e, t) {
+	if (e.size !== t.size) return !1;
+	for (let [n, r] of e) {
+		let e = t.get(n);
+		if (!e || r.x !== e.x || r.y !== e.y || r.w !== e.w || r.h !== e.h) return !1;
+	}
+	return !0;
+}
+function l(e, t) {
+	return t !== null && !c(e, t);
+}
+var u = {
+	baseline: null,
+	frozen: !1,
+	seenRevision: null
+};
+function d(e, t) {
+	switch (t.type) {
+		case "reset": return u;
+		case "observe": {
+			if (e.baseline === null) return {
+				baseline: t.layout,
+				frozen: !1,
+				seenRevision: t.editRevision
+			};
+			let n = t.editRevision !== e.seenRevision;
+			return e.frozen ? n ? {
+				...e,
+				seenRevision: t.editRevision
+			} : e : n ? {
+				baseline: e.baseline,
+				frozen: !0,
+				seenRevision: t.editRevision
+			} : c(t.layout, e.baseline) ? e : {
+				baseline: t.layout,
+				frozen: !1,
+				seenRevision: t.editRevision
+			};
+		}
+		case "saved": return e.baseline === null ? {
+			baseline: t.layout,
+			frozen: !1,
+			seenRevision: t.editRevision
+		} : {
+			baseline: t.layout,
+			frozen: e.seenRevision !== null && e.seenRevision > t.editRevision,
+			seenRevision: e.seenRevision
+		};
+	}
+}
+function f(e, t) {
+	return e.frozen && l(t, e.baseline);
+}
+//#endregion
+export { u as INITIAL_LAYOUT_BASELINE, f as isLayoutBaselineDirty, o as layoutFromWidgets, s as layoutItemsFromPositionUpdates, a as normaliseLayout, d as reduceLayoutBaseline };

package/dist/bigconsole/utils/listSort.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Shared "Sort by" model for BigConsole list pages (BOFF-8679).
+ *
+ * ★ One definition of the sort values, the comparator and the option labels, so
+ * the visible `SortBySelect`, the page's own list pipeline and the assistant's
+ * page-control adapter (`assistant/pageControls.ts`) cannot disagree: a person
+ * who picks "Name Z–A" from the menu and a person who says "sort by name
+ * descending" set the SAME state and get the SAME list.
+ *
+ * Pure: no React, no DOM, no i18n provider (labels come in through `Tr`).
+ *
+ * Only fields the list data really carries are offered:
+ * - Name: every dashboard has `name`; a data sink may have a null `name`, in
+ *   which case its `key` is what the card and the table show, so that is what
+ *   sorts.
+ * - Last updated: `updatedAt` on both. A row with no parseable date sorts last
+ *   in both directions (it has no "age" to rank).
+ */
+export type ListSortValue = 'default' | 'name-asc' | 'name-desc' | 'updated-desc' | 'updated-asc';
+export type ListSortField = 'name' | 'updated';
+export type SortTr = (key: string, fallback: string) => string;
+export interface ListSortOption {
+    value: ListSortValue;
+    label: string;
+}
+/** How a list item exposes the two sortable fields. */
+export interface ListSortKeys<T> {
+    /** The text the row shows as its name. */
+    name: (item: T) => string;
+    /** ISO timestamp of the last update, if any. */
+    updatedAt: (item: T) => string | null | undefined;
+}
+/** The i18n key and English source of every label used by the control. */
+export declare const LIST_SORT_COPY: {
+    readonly label: {
+        readonly key: "bigconsole.listSort.label";
+        readonly en: "Sort by";
+    };
+    readonly default: {
+        readonly key: "bigconsole.listSort.default";
+        readonly en: "Default order";
+    };
+    readonly nameAsc: {
+        readonly key: "bigconsole.listSort.nameAsc";
+        readonly en: "Name A–Z";
+    };
+    readonly nameDesc: {
+        readonly key: "bigconsole.listSort.nameDesc";
+        readonly en: "Name Z–A";
+    };
+    readonly updatedDesc: {
+        readonly key: "bigconsole.listSort.updatedDesc";
+        readonly en: "Last updated: newest";
+    };
+    readonly updatedAsc: {
+        readonly key: "bigconsole.listSort.updatedAsc";
+        readonly en: "Last updated: oldest";
+    };
+    readonly fieldName: {
+        readonly key: "bigconsole.listSort.field.name";
+        readonly en: "Name";
+    };
+    readonly fieldUpdated: {
+        readonly key: "bigconsole.listSort.field.updated";
+        readonly en: "Last updated";
+    };
+};
+/**
+ * The list ordered by `value`. `default` returns the items in the order given
+ * (the page's own default order, untouched). The sort is stable: rows that tie
+ * keep their incoming order, so a re-sort never shuffles equal rows.
+ */
+export declare function sortList<T>(items: readonly T[], value: ListSortValue, keys: ListSortKeys<T>): T[];
+/**
+ * The options the visible control lists, in its words. `withDefault` adds the
+ * "Default order" entry for a page whose natural order is not one of the four
+ * (Dashboards: the server's order). A page whose default IS one of them
+ * (Data Sinks: newest first) omits it and starts on that value.
+ */
+export declare function listSortOptions(tr: SortTr, withDefault: boolean): ListSortOption[];

package/dist/bigconsole/utils/listSort.js

@@ -0,0 +1,85 @@
+//#region src/bigconsole/utils/listSort.ts
+var e = {
+	label: {
+		key: "bigconsole.listSort.label",
+		en: "Sort by"
+	},
+	default: {
+		key: "bigconsole.listSort.default",
+		en: "Default order"
+	},
+	nameAsc: {
+		key: "bigconsole.listSort.nameAsc",
+		en: "Name A–Z"
+	},
+	nameDesc: {
+		key: "bigconsole.listSort.nameDesc",
+		en: "Name Z–A"
+	},
+	updatedDesc: {
+		key: "bigconsole.listSort.updatedDesc",
+		en: "Last updated: newest"
+	},
+	updatedAsc: {
+		key: "bigconsole.listSort.updatedAsc",
+		en: "Last updated: oldest"
+	},
+	fieldName: {
+		key: "bigconsole.listSort.field.name",
+		en: "Name"
+	},
+	fieldUpdated: {
+		key: "bigconsole.listSort.field.updated",
+		en: "Last updated"
+	}
+}, t = new Intl.Collator(void 0, {
+	sensitivity: "base",
+	numeric: !0
+});
+function n(e) {
+	if (!e) return null;
+	let t = new Date(e).getTime();
+	return Number.isNaN(t) ? null : t;
+}
+function r(e, r, i) {
+	let a = [...e];
+	switch (r) {
+		case "default": return a;
+		case "name-asc": return a.sort((e, n) => t.compare(i.name(e), i.name(n)));
+		case "name-desc": return a.sort((e, n) => t.compare(i.name(n), i.name(e)));
+		case "updated-desc":
+		case "updated-asc": {
+			let e = r === "updated-desc" ? -1 : 1;
+			return a.sort((t, r) => {
+				let a = n(i.updatedAt(t)), o = n(i.updatedAt(r));
+				return a === null && o === null ? 0 : a === null ? 1 : o === null ? -1 : (a - o) * e;
+			});
+		}
+	}
+}
+function i(t, n) {
+	let r = [
+		{
+			value: "name-asc",
+			label: t(e.nameAsc.key, e.nameAsc.en)
+		},
+		{
+			value: "name-desc",
+			label: t(e.nameDesc.key, e.nameDesc.en)
+		},
+		{
+			value: "updated-desc",
+			label: t(e.updatedDesc.key, e.updatedDesc.en)
+		},
+		{
+			value: "updated-asc",
+			label: t(e.updatedAsc.key, e.updatedAsc.en)
+		}
+	];
+	return n ? [{
+		value: "default",
+		label: t(e.default.key, e.default.en)
+	}, ...r] : r;
+}
+//#endregion
+export { e as LIST_SORT_COPY, i as listSortOptions, r as sortList };

package/dist/bigconsole/utils/widgetFormDirty.d.ts

@@ -0,0 +1,16 @@
+/** True when `form` differs by value from `baseline`. Either side missing is clean. */
+export declare function isWidgetFormEdited<T>(form: T | null | undefined, baseline: T | null | undefined): boolean;
+/**
+ * Adds an inferred DataSink binding to a form that is bound to `parserId` and has none.
+ *
+ * The widget inspector infers an absent `dataSinkId` from the parser's input sink key once the
+ * parser resolves (AI-created widgets bind a parser without duplicating its input sink id). That
+ * is the panel filling in what the widget already means, not an edit by the person. It is
+ * applied to the form AND to the baseline with this one function, so the value compare of
+ * `isWidgetFormEdited` reads clean. Returns the same object when nothing applies, so a state
+ * updater using it does not trigger a re-render.
+ */
+export declare function withInferredDataSink<T extends {
+    parserId?: string | null;
+    dataSinkId?: string | null;
+}>(form: T | null | undefined, parserId: string, dataSinkId: string): T | null;

package/dist/bigconsole/utils/widgetFormDirty.js

@@ -0,0 +1,13 @@
+import { isDirty as e } from "./formDirty.js";
+//#region src/bigconsole/utils/widgetFormDirty.ts
+function t(t, n) {
+	return t == null || n == null ? !1 : e(t, n);
+}
+function n(e, t, n) {
+	return e == null ? null : e.parserId !== t || e.dataSinkId ? e : {
+		...e,
+		dataSinkId: n
+	};
+}
+//#endregion
+export { t as isWidgetFormEdited, n as withInferredDataSink };

package/dist/bigconsole/utils/widgetTypeMapping.d.ts

@@ -1,6 +1,6 @@
 import { WidgetType as InternalWidgetType } from '../types';
 
-export type FederationWidgetType = 'AREA_CHART' | 'BAR_CHART' | 'FUNNEL' | 'HEATMAP' | 'KPI' | 'LINE_CHART' | 'PIE_CHART' | 'RETENTION' | 'TABLE';
+export type FederationWidgetType = 'AREA_CHART' | 'BAR_CHART' | 'FUNNEL' | 'HEATMAP' | 'KPI' | 'LINE_CHART' | 'PIE_CHART' | 'RETENTION' | 'TABLE' | 'MAP' | 'WATERFALL' | 'SANKEY' | 'BOX_PLOT';
 /**
  * Maps internal UI widget types to federation-accessible GraphQL enum values.
  *

package/dist/bigconsole/utils/widgetTypeMapping.js

@@ -4,6 +4,9 @@ function e(e) {
 		kpi_card_comparison: "KPI",
 		metric_card: "KPI",
 		chart: "LINE_CHART",
+		waterfall: "WATERFALL",
+		sankey: "SANKEY",
+		box_plot: "BOX_PLOT",
 		funnel_chart: "FUNNEL",
 		table: "TABLE",
 		pivot_table: "TABLE",
@@ -13,7 +16,7 @@ function e(e) {
 		form: "TABLE",
 		text: "KPI",
 		iframe: "KPI",
-		map: "HEATMAP",
+		map: "MAP",
 		heatmap: "HEATMAP",
 		calendar: "TABLE",
 		kanban: "TABLE",
@@ -32,6 +35,10 @@ function t(e) {
 		TABLE: "table",
 		FUNNEL: "funnel_chart",
 		HEATMAP: "heatmap",
+		MAP: "map",
+		WATERFALL: "waterfall",
+		SANKEY: "sankey",
+		BOX_PLOT: "box_plot",
 		RETENTION: "table"
 	}[e.toUpperCase()] || "metric_card";
 }
@@ -45,7 +52,11 @@ function n(e) {
 		"LINE_CHART",
 		"PIE_CHART",
 		"RETENTION",
-		"TABLE"
+		"TABLE",
+		"MAP",
+		"WATERFALL",
+		"SANKEY",
+		"BOX_PLOT"
 	]).has(e.toUpperCase());
 }
 function r(t) {

package/dist/bigconsole/workflowOpen.js

@@ -1,31 +1,32 @@
 import { WorkflowDefinitionExistsDocument as e } from "../generated/wspace-operations.js";
 import { BOOTSTRAP_RETRY_DELAY_MS as t } from "./constants.js";
+import { hasGraphQLErrorCode as n } from "./utils/backendError.js";
 //#region src/bigconsole/workflowOpen.ts
-var n = { createWorkflow: !0 }, r = { state: n };
-function i(e) {
+var r = new Set(["NOT_FOUND"]), i = { createWorkflow: !0 }, a = { state: i };
+function o(e) {
 	return typeof e == "object" && !!e && e.createWorkflow === !0;
 }
-function a(e) {
+function s(e) {
 	return { query: (t) => e.query(t) };
 }
-async function o(t, n) {
+async function c(t, i) {
 	try {
-		let r = await t.query({
+		let a = await t.query({
 			query: e,
-			variables: { workflowKey: n },
+			variables: { workflowKey: i },
 			fetchPolicy: "network-only"
 		});
-		return r.error ? "error" : r.data?.workflowDefinition ? "found" : "absent";
-	} catch {
-		return "error";
+		return a.error ? n(a.error, r) ? "absent" : "error" : a.data?.workflowDefinition ? "found" : "absent";
+	} catch (e) {
+		return n(e, r) ? "absent" : "error";
 	}
 }
-var s = (e) => new Promise((t) => setTimeout(t, e));
-async function c(e, n, { retryDelayMs: r = t, sleep: i = s } = {}) {
-	return await o(e, n) === "found" ? "found" : (await i(r), o(e, n));
+var l = (e) => new Promise((t) => setTimeout(t, e));
+async function u(e, n, { retryDelayMs: r = t, sleep: i = l } = {}) {
+	return await c(e, n) === "found" ? "found" : (await i(r), c(e, n));
 }
-function l({ key: e, createIntent: t, verifiedKey: n, absentKey: r, failedKey: i }) {
+function d({ key: e, createIntent: t, verifiedKey: n, absentKey: r, failedKey: i }) {
 	return t || n === e ? "builder" : r === e ? "not-found" : i === e ? "failed" : "checking";
 }
 //#endregion
-export { n as CREATE_WORKFLOW_STATE, r as NEW_WORKFLOW_NAV, l as decideWorkflowOpenView, i as isCreateIntent, a as toLookupClient, c as verifyWorkflowKey };
+export { i as CREATE_WORKFLOW_STATE, a as NEW_WORKFLOW_NAV, d as decideWorkflowOpenView, o as isCreateIntent, s as toLookupClient, u as verifyWorkflowKey };

package/dist/generated/wspace-operations.d.ts

@@ -5049,7 +5049,9 @@ export type WidgetTranslationFieldsFragment = {
 };
 export type WidgetTypeInfoFieldsFragment = {
     __typename?: 'WidgetTypeInfo';
-    type: Types.WidgetType;
+    type: string;
+    federationType?: string | null;
+    source?: string | null;
     label: string;
     description: string;
     icon: string;
@@ -5842,6 +5844,37 @@ export type GetEventWebhookMappingQuery = {
         } | null;
     } | null;
 };
+export type GetLegacyWidgetTypesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetLegacyWidgetTypesQuery = {
+    __typename?: 'Query';
+    getWidgetTypes: Array<{
+        __typename?: 'WidgetTypeInfo';
+        type: string;
+        source?: string | null;
+        label: string;
+        description: string;
+        icon: string;
+        category: string;
+        defaultConfig: Record<string, unknown>;
+        defaultSize: {
+            __typename?: 'WidgetSizeInfo';
+            width: number;
+            height: number;
+        };
+        minSize: {
+            __typename?: 'WidgetSizeInfo';
+            width: number;
+            height: number;
+        };
+        maxSize: {
+            __typename?: 'WidgetSizeInfo';
+            width: number;
+            height: number;
+        };
+    }>;
+};
 export type GetWidgetQueryVariables = Types.Exact<{
     id: Types.Scalars['ID']['input'];
 }>;
@@ -5995,7 +6028,9 @@ export type GetWidgetTypesQuery = {
     __typename?: 'Query';
     getWidgetTypes: Array<{
         __typename?: 'WidgetTypeInfo';
-        type: Types.WidgetType;
+        type: string;
+        federationType?: string | null;
+        source?: string | null;
         label: string;
         description: string;
         icon: string;
@@ -10704,6 +10739,30 @@ export type GetEventWebhookMappingQueryHookResult = ReturnType<typeof useGetEven
 export type GetEventWebhookMappingLazyQueryHookResult = ReturnType<typeof useGetEventWebhookMappingLazyQuery>;
 export type GetEventWebhookMappingSuspenseQueryHookResult = ReturnType<typeof useGetEventWebhookMappingSuspenseQuery>;
 export type GetEventWebhookMappingQueryResult = Apollo.QueryResult<Types.GetEventWebhookMappingQuery, Types.GetEventWebhookMappingQueryVariables>;
+export declare const GetLegacyWidgetTypesDocument: Apollo.DocumentNode;
+/**
+ * __useGetLegacyWidgetTypesQuery__
+ *
+ * To run a query within a React component, call `useGetLegacyWidgetTypesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetLegacyWidgetTypesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useGetLegacyWidgetTypesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetLegacyWidgetTypesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables, "empty" | "complete" | "streaming", Types.GetLegacyWidgetTypesQueryVariables>;
+export declare function useGetLegacyWidgetTypesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetLegacyWidgetTypesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>;
+export declare function useGetLegacyWidgetTypesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetLegacyWidgetTypesQuery | undefined, Types.GetLegacyWidgetTypesQueryVariables>;
+export type GetLegacyWidgetTypesQueryHookResult = ReturnType<typeof useGetLegacyWidgetTypesQuery>;
+export type GetLegacyWidgetTypesLazyQueryHookResult = ReturnType<typeof useGetLegacyWidgetTypesLazyQuery>;
+export type GetLegacyWidgetTypesSuspenseQueryHookResult = ReturnType<typeof useGetLegacyWidgetTypesSuspenseQuery>;
+export type GetLegacyWidgetTypesQueryResult = Apollo.QueryResult<Types.GetLegacyWidgetTypesQuery, Types.GetLegacyWidgetTypesQueryVariables>;
 export declare const GetWidgetDocument: Apollo.DocumentNode;
 /**
  * __useGetWidgetQuery__