@gxp-dev/mod-ui 2.0.0

package/dist/definitions/elements/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/definitions/elements/index.ts"],"names":[],"mappings":"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"}

package/dist/definitions/elements/index.js

@@ -0,0 +1,139 @@
+import { ActionElementMetadata as C, ActionElementEditConfig as y, ActionStyleMetadataMap as a } from "./ActionElement.js";
+import { ActionElementDefaults as dt } from "./ActionElement.js";
+import { BooleanElementMetadata as g, BooleanElementEditConfig as S, BooleanStyleMetadataMap as n } from "./BooleanElement.js";
+import { BooleanElementDefaults as ft } from "./BooleanElement.js";
+import { CardLayoutElementMetadata as D, CardLayoutElementEditConfig as k, CardStyleMetadataMap as l } from "./CardLayoutElement.js";
+import { CardLayoutElementDefaults as ct } from "./CardLayoutElement.js";
+import { BuilderElementMetadata as b, BuilderElementEditConfig as x, BuilderStyleMetadataMap as i } from "./BuilderElement.js";
+import { BuilderElementDefaults as Mt } from "./BuilderElement.js";
+import { CodeElementMetadata as B, CodeElementEditConfig as O, CodeStyleMetadataMap as r } from "./CodeElement.js";
+import { CodeElementDefaults as Ct } from "./CodeElement.js";
+import { ComponentsElementMetadata as A, ComponentsElementEditConfig as F, ComponentsStyleMetadataMap as m } from "./ComponentsElement.js";
+import { ComponentsElementDefaults as gt } from "./ComponentsElement.js";
+import { ConfigurationBlockElementMetadata as I, ConfigurationBlockElementEditConfig as L, ConfigurationBlockStyleMetadataMap as d } from "./ConfigurationBlockElement.js";
+import { ConfigurationBlockElementDefaults as Dt } from "./ConfigurationBlockElement.js";
+import { DisplayElementMetadata as P, DisplayElementEditConfig as j, DisplayStyleMetadataMap as p } from "./DisplayElement.js";
+import { DisplayElementDefaults as bt } from "./DisplayElement.js";
+import { EditorElementMetadata as v, EditorElementEditConfig as h, EditorStyleMetadataMap as f } from "./EditorElement.js";
+import { EditorElementDefaults as Bt } from "./EditorElement.js";
+import { FileElementMetadata as q, FileElementEditConfig as w, FileStyleMetadataMap as E } from "./FileElement.js";
+import { FileElementDefaults as At } from "./FileElement.js";
+import { InputElementMetadata as z, InputElementEditConfig as G, InputStyleMetadataMap as c } from "./InputElement.js";
+import { InputElementDefaults as It } from "./InputElement.js";
+import { OptionSelectElementMetadata as H, OptionSelectElementEditConfig as J, OptionSelectStyleMetadataMap as u } from "./OptionSelectElement.js";
+import { OptionSelectElementDefaults as Pt } from "./OptionSelectElement.js";
+import { PickerElementMetadata as K, PickerElementEditConfig as N, PickerStyleMetadataMap as M } from "./PickerElement.js";
+import { PickerElementDefaults as vt } from "./PickerElement.js";
+const at = {
+  action: C,
+  boolean: g,
+  builder: b,
+  card: D,
+  code: B,
+  components: A,
+  "configuration-block": I,
+  display: P,
+  editor: v,
+  file: q,
+  input: z,
+  "option-select": H,
+  picker: K
+}, nt = {
+  action: a,
+  boolean: n,
+  builder: i,
+  card: l,
+  code: r,
+  components: m,
+  "configuration-block": d,
+  display: p,
+  editor: f,
+  file: E,
+  input: c,
+  "option-select": u,
+  picker: M
+};
+function t(o) {
+  return Object.entries(o).filter((e) => e[1] != null).map(([e, s]) => ({ value: e, label: s.displayLabel }));
+}
+const lt = {
+  action: t(a),
+  boolean: t(n),
+  builder: t(i),
+  card: t(l),
+  code: t(r),
+  components: t(m),
+  "configuration-block": t(d),
+  display: t(p),
+  editor: t(f),
+  file: t(E),
+  input: t(c),
+  "option-select": t(u),
+  picker: t(M)
+}, Q = {
+  action: y,
+  boolean: S,
+  builder: x,
+  card: k,
+  code: O,
+  components: F,
+  "configuration-block": L,
+  display: j,
+  editor: h,
+  file: w,
+  input: G,
+  "option-select": J,
+  picker: N
+};
+function it(o) {
+  const e = o.split(".")[0];
+  return Q[e];
+}
+export {
+  dt as ActionElementDefaults,
+  y as ActionElementEditConfig,
+  C as ActionElementMetadata,
+  ft as BooleanElementDefaults,
+  S as BooleanElementEditConfig,
+  g as BooleanElementMetadata,
+  Mt as BuilderElementDefaults,
+  x as BuilderElementEditConfig,
+  b as BuilderElementMetadata,
+  at as CardElementMetadataMap,
+  lt as CardElementStylesMap,
+  ct as CardLayoutElementDefaults,
+  k as CardLayoutElementEditConfig,
+  D as CardLayoutElementMetadata,
+  l as CardStyleMetadataMap,
+  Q as CategoryEditConfigMap,
+  nt as CategoryStyleMetadataMaps,
+  Ct as CodeElementDefaults,
+  O as CodeElementEditConfig,
+  B as CodeElementMetadata,
+  gt as ComponentsElementDefaults,
+  F as ComponentsElementEditConfig,
+  A as ComponentsElementMetadata,
+  Dt as ConfigurationBlockElementDefaults,
+  L as ConfigurationBlockElementEditConfig,
+  I as ConfigurationBlockElementMetadata,
+  bt as DisplayElementDefaults,
+  j as DisplayElementEditConfig,
+  P as DisplayElementMetadata,
+  Bt as EditorElementDefaults,
+  h as EditorElementEditConfig,
+  v as EditorElementMetadata,
+  At as FileElementDefaults,
+  w as FileElementEditConfig,
+  q as FileElementMetadata,
+  It as InputElementDefaults,
+  G as InputElementEditConfig,
+  z as InputElementMetadata,
+  Pt as OptionSelectElementDefaults,
+  J as OptionSelectElementEditConfig,
+  H as OptionSelectElementMetadata,
+  vt as PickerElementDefaults,
+  N as PickerElementEditConfig,
+  K as PickerElementMetadata,
+  it as getElementEditConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/definitions/elements/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/definitions/elements/index.ts"],"sourcesContent":["/**\n * Public barrel for every CardElement category.\n *\n * Each category exports four artifacts:\n *   - `<Category>Element` interface (the JSON shape)\n *   - `<Category>Style` union (the `style` discriminator's possible values)\n *   - `<Category>ElementDefaults` const (used by FormBuilder + adapters)\n *   - `<Category>ElementMetadata` const (palette label, icon, description)\n *   - `<Category>ElementEditConfig` const (the FormBuilder inspector schema)\n *\n * The `CardElement` union below is the JSON shape of any element. The\n * engine's `ElementRenderer` accepts a `CardElement` and uses `type`\n * (+ `style`) to resolve the renderer component.\n */\n\nexport type {\n  ActionElement,\n  ActionGroupItem,\n  ActionSize,\n  ActionStyle,\n  ActionVariant,\n} from \"./ActionElement\"\nexport {\n  ActionElementDefaults,\n  ActionElementEditConfig,\n  ActionElementMetadata,\n} from \"./ActionElement\"\n\nexport type { BooleanElement, BooleanStyle } from \"./BooleanElement\"\nexport {\n  BooleanElementDefaults,\n  BooleanElementEditConfig,\n  BooleanElementMetadata,\n} from \"./BooleanElement\"\n\nexport type { CardLayoutElement, CardStyle } from \"./CardLayoutElement\"\nexport {\n  CardLayoutElementDefaults,\n  CardLayoutElementEditConfig,\n  CardLayoutElementMetadata,\n  CardStyleMetadataMap,\n} from \"./CardLayoutElement\"\n\nexport type { BuilderElement, BuilderStyle } from \"./BuilderElement\"\nexport {\n  BuilderElementDefaults,\n  BuilderElementEditConfig,\n  BuilderElementMetadata,\n} from \"./BuilderElement\"\n\nexport type { CodeElement, CodeStyle } from \"./CodeElement\"\nexport {\n  CodeElementDefaults,\n  CodeElementEditConfig,\n  CodeElementMetadata,\n} from \"./CodeElement\"\n\nexport type {\n  ComponentsElement,\n  ComponentsSize,\n  ComponentsStyle,\n} from \"./ComponentsElement\"\nexport {\n  ComponentsElementDefaults,\n  ComponentsElementEditConfig,\n  ComponentsElementMetadata,\n} from \"./ComponentsElement\"\n\nexport type {\n  ConfigurationBlockElement,\n  ConfigurationBlockStyle,\n} from \"./ConfigurationBlockElement\"\nexport {\n  ConfigurationBlockElementDefaults,\n  ConfigurationBlockElementEditConfig,\n  ConfigurationBlockElementMetadata,\n} from \"./ConfigurationBlockElement\"\n\nexport type {\n  DisplayContentType,\n  DisplayElement,\n  DisplayStyle,\n} from \"./DisplayElement\"\nexport {\n  DisplayElementDefaults,\n  DisplayElementEditConfig,\n  DisplayElementMetadata,\n} from \"./DisplayElement\"\n\nexport type { EditorElement, EditorStyle } from \"./EditorElement\"\nexport {\n  EditorElementDefaults,\n  EditorElementEditConfig,\n  EditorElementMetadata,\n} from \"./EditorElement\"\n\nexport type { FileElement, FileStyle } from \"./FileElement\"\nexport {\n  FileElementDefaults,\n  FileElementEditConfig,\n  FileElementMetadata,\n} from \"./FileElement\"\n\nexport type {\n  InputContentType,\n  InputElement,\n  InputStyle,\n} from \"./InputElement\"\nexport {\n  InputElementDefaults,\n  InputElementEditConfig,\n  InputElementMetadata,\n} from \"./InputElement\"\n\nexport type {\n  OptionSelectElement,\n  OptionSelectStyle,\n} from \"./OptionSelectElement\"\nexport {\n  OptionSelectElementDefaults,\n  OptionSelectElementEditConfig,\n  OptionSelectElementMetadata,\n} from \"./OptionSelectElement\"\n\nexport type {\n  ColorPickerFormat,\n  PickerElement,\n  PickerStyle,\n} from \"./PickerElement\"\nexport {\n  PickerElementDefaults,\n  PickerElementEditConfig,\n  PickerElementMetadata,\n} from \"./PickerElement\"\n\nimport type { ActionElement } from \"./ActionElement\"\nimport type { BooleanElement } from \"./BooleanElement\"\nimport type { BuilderElement } from \"./BuilderElement\"\nimport type { CardLayoutElement } from \"./CardLayoutElement\"\nimport type { CodeElement } from \"./CodeElement\"\nimport type { ComponentsElement } from \"./ComponentsElement\"\nimport type { ConfigurationBlockElement } from \"./ConfigurationBlockElement\"\nimport type { DisplayElement } from \"./DisplayElement\"\nimport type { EditorElement } from \"./EditorElement\"\nimport type { FileElement } from \"./FileElement\"\nimport type { InputElement } from \"./InputElement\"\nimport type { OptionSelectElement } from \"./OptionSelectElement\"\nimport type { PickerElement } from \"./PickerElement\"\n\nimport { ActionElementEditConfig, ActionElementMetadata, ActionStyleMetadataMap } from \"./ActionElement\"\nimport { BooleanElementEditConfig, BooleanElementMetadata, BooleanStyleMetadataMap } from \"./BooleanElement\"\nimport { BuilderElementEditConfig, BuilderElementMetadata, BuilderStyleMetadataMap } from \"./BuilderElement\"\nimport { CardLayoutElementEditConfig, CardLayoutElementMetadata, CardStyleMetadataMap } from \"./CardLayoutElement\"\nimport { CodeElementEditConfig, CodeElementMetadata, CodeStyleMetadataMap } from \"./CodeElement\"\nimport { ComponentsElementEditConfig, ComponentsElementMetadata, ComponentsStyleMetadataMap } from \"./ComponentsElement\"\nimport { ConfigurationBlockElementEditConfig, ConfigurationBlockElementMetadata, ConfigurationBlockStyleMetadataMap } from \"./ConfigurationBlockElement\"\nimport { DisplayElementEditConfig, DisplayElementMetadata, DisplayStyleMetadataMap } from \"./DisplayElement\"\nimport { EditorElementEditConfig, EditorElementMetadata, EditorStyleMetadataMap } from \"./EditorElement\"\nimport { FileElementEditConfig, FileElementMetadata, FileStyleMetadataMap } from \"./FileElement\"\nimport { InputElementEditConfig, InputElementMetadata, InputStyleMetadataMap } from \"./InputElement\"\nimport { OptionSelectElementEditConfig, OptionSelectElementMetadata, OptionSelectStyleMetadataMap } from \"./OptionSelectElement\"\nimport { PickerElementEditConfig, PickerElementMetadata, PickerStyleMetadataMap } from \"./PickerElement\"\nimport type { EditConfig } from \"@/definitions/shared/base\"\n\n/**\n * The discriminated-union JSON shape of any CardElement. Narrowing on\n * `type` gives full intellisense for the style-specific fields.\n */\nexport type CardElement =\n  | ActionElement\n  | BooleanElement\n  | BuilderElement\n  | CardLayoutElement\n  | CodeElement\n  | ComponentsElement\n  | ConfigurationBlockElement\n  | DisplayElement\n  | EditorElement\n  | FileElement\n  | InputElement\n  | OptionSelectElement\n  | PickerElement\n\n/**\n * Runtime registry of element metadata keyed by `type`. Used by the\n * FormBuilder palette to enumerate available elements.\n */\nexport const CardElementMetadataMap = {\n  action: ActionElementMetadata,\n  boolean: BooleanElementMetadata,\n  builder: BuilderElementMetadata,\n  card: CardLayoutElementMetadata,\n  code: CodeElementMetadata,\n  components: ComponentsElementMetadata,\n  \"configuration-block\": ConfigurationBlockElementMetadata,\n  display: DisplayElementMetadata,\n  editor: EditorElementMetadata,\n  file: FileElementMetadata,\n  input: InputElementMetadata,\n  \"option-select\": OptionSelectElementMetadata,\n  picker: PickerElementMetadata,\n} as const\n\n/** Registry of all per-style metadata maps, keyed by element category. */\nexport const CategoryStyleMetadataMaps = {\n  action: ActionStyleMetadataMap,\n  boolean: BooleanStyleMetadataMap,\n  builder: BuilderStyleMetadataMap,\n  card: CardStyleMetadataMap,\n  code: CodeStyleMetadataMap,\n  components: ComponentsStyleMetadataMap,\n  \"configuration-block\": ConfigurationBlockStyleMetadataMap,\n  display: DisplayStyleMetadataMap,\n  editor: EditorStyleMetadataMap,\n  file: FileStyleMetadataMap,\n  input: InputStyleMetadataMap,\n  \"option-select\": OptionSelectStyleMetadataMap,\n  picker: PickerStyleMetadataMap,\n} as const\n\nfunction deriveStyles(\n  map: Partial<Record<string, { displayLabel: string; description: string }>>,\n): ReadonlyArray<{ value: string; label: string }> {\n  return Object.entries(map)\n    .filter((entry): entry is [string, { displayLabel: string; description: string }] => entry[1] != null)\n    .map(([value, meta]) => ({ value, label: meta.displayLabel }))\n}\n\n/**\n * All style variants per element category, derived from each category's\n * StyleMetadataMap. Adding a new style only requires updating the category's\n * definition file — no changes needed here.\n */\nexport const CardElementStylesMap = {\n  action: deriveStyles(ActionStyleMetadataMap),\n  boolean: deriveStyles(BooleanStyleMetadataMap),\n  builder: deriveStyles(BuilderStyleMetadataMap),\n  card: deriveStyles(CardStyleMetadataMap),\n  code: deriveStyles(CodeStyleMetadataMap),\n  components: deriveStyles(ComponentsStyleMetadataMap),\n  \"configuration-block\": deriveStyles(ConfigurationBlockStyleMetadataMap),\n  display: deriveStyles(DisplayStyleMetadataMap),\n  editor: deriveStyles(EditorStyleMetadataMap),\n  file: deriveStyles(FileStyleMetadataMap),\n  input: deriveStyles(InputStyleMetadataMap),\n  \"option-select\": deriveStyles(OptionSelectStyleMetadataMap),\n  picker: deriveStyles(PickerStyleMetadataMap),\n} satisfies Record<keyof typeof CardElementMetadataMap, ReadonlyArray<{ value: string; label: string }>>\n\n/**\n * EditConfig for every element category, keyed by category name.\n * Used by the FormBuilder inspector to render element-specific fields.\n */\nexport const CategoryEditConfigMap = {\n  action: ActionElementEditConfig,\n  boolean: BooleanElementEditConfig,\n  builder: BuilderElementEditConfig,\n  card: CardLayoutElementEditConfig,\n  code: CodeElementEditConfig,\n  components: ComponentsElementEditConfig,\n  \"configuration-block\": ConfigurationBlockElementEditConfig,\n  display: DisplayElementEditConfig,\n  editor: EditorElementEditConfig,\n  file: FileElementEditConfig,\n  input: InputElementEditConfig,\n  \"option-select\": OptionSelectElementEditConfig,\n  picker: PickerElementEditConfig,\n} as const\n\n/**\n * Look up the EditConfig for a dot-notation element type (e.g. `\"input.text\"`).\n * Returns the category-level EditConfig whose `conditionParams` narrow which\n * fields are visible for the specific style.\n */\nexport function getElementEditConfig(type: string): EditConfig | undefined {\n  const category = type.split(\".\")[0] as keyof typeof CategoryEditConfigMap\n  return CategoryEditConfigMap[category] as EditConfig | undefined\n}\n"],"names":["CardElementMetadataMap","ActionElementMetadata","BooleanElementMetadata","BuilderElementMetadata","CardLayoutElementMetadata","CodeElementMetadata","ComponentsElementMetadata","ConfigurationBlockElementMetadata","DisplayElementMetadata","EditorElementMetadata","FileElementMetadata","InputElementMetadata","OptionSelectElementMetadata","PickerElementMetadata","CategoryStyleMetadataMaps","ActionStyleMetadataMap","BooleanStyleMetadataMap","BuilderStyleMetadataMap","CardStyleMetadataMap","CodeStyleMetadataMap","ComponentsStyleMetadataMap","ConfigurationBlockStyleMetadataMap","DisplayStyleMetadataMap","EditorStyleMetadataMap","FileStyleMetadataMap","InputStyleMetadataMap","OptionSelectStyleMetadataMap","PickerStyleMetadataMap","deriveStyles","map","entry","value","meta","CardElementStylesMap","CategoryEditConfigMap","ActionElementEditConfig","BooleanElementEditConfig","BuilderElementEditConfig","CardLayoutElementEditConfig","CodeElementEditConfig","ComponentsElementEditConfig","ConfigurationBlockElementEditConfig","DisplayElementEditConfig","EditorElementEditConfig","FileElementEditConfig","InputElementEditConfig","OptionSelectElementEditConfig","PickerElementEditConfig","getElementEditConfig","type","category"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2LO,MAAMA,KAAyB;AAAA,EACpC,QAAQC;AAAAA,EACR,SAASC;AAAAA,EACT,SAASC;AAAAA,EACT,MAAMC;AAAAA,EACN,MAAMC;AAAAA,EACN,YAAYC;AAAAA,EACZ,uBAAuBC;AAAAA,EACvB,SAASC;AAAAA,EACT,QAAQC;AAAAA,EACR,MAAMC;AAAAA,EACN,OAAOC;AAAAA,EACP,iBAAiBC;AAAAA,EACjB,QAAQC;AACV,GAGaC,KAA4B;AAAA,EACvC,QAAQC;AAAA,EACR,SAASC;AAAA,EACT,SAASC;AAAA,EACT,MAAMC;AAAAA,EACN,MAAMC;AAAA,EACN,YAAYC;AAAA,EACZ,uBAAuBC;AAAA,EACvB,SAASC;AAAA,EACT,QAAQC;AAAA,EACR,MAAMC;AAAA,EACN,OAAOC;AAAA,EACP,iBAAiBC;AAAA,EACjB,QAAQC;AACV;AAEA,SAASC,EACPC,GACiD;AACjD,SAAO,OAAO,QAAQA,CAAG,EACtB,OAAO,CAACC,MAA4EA,EAAM,CAAC,KAAK,IAAI,EACpG,IAAI,CAAC,CAACC,GAAOC,CAAI,OAAO,EAAE,OAAAD,GAAO,OAAOC,EAAK,aAAA,EAAe;AACjE;AAOO,MAAMC,KAAuB;AAAA,EAClC,QAAQL,EAAab,CAAsB;AAAA,EAC3C,SAASa,EAAaZ,CAAuB;AAAA,EAC7C,SAASY,EAAaX,CAAuB;AAAA,EAC7C,MAAMW,EAAaV,CAAoB;AAAA,EACvC,MAAMU,EAAaT,CAAoB;AAAA,EACvC,YAAYS,EAAaR,CAA0B;AAAA,EACnD,uBAAuBQ,EAAaP,CAAkC;AAAA,EACtE,SAASO,EAAaN,CAAuB;AAAA,EAC7C,QAAQM,EAAaL,CAAsB;AAAA,EAC3C,MAAMK,EAAaJ,CAAoB;AAAA,EACvC,OAAOI,EAAaH,CAAqB;AAAA,EACzC,iBAAiBG,EAAaF,CAA4B;AAAA,EAC1D,QAAQE,EAAaD,CAAsB;AAC7C,GAMaO,IAAwB;AAAA,EACnC,QAAQC;AAAAA,EACR,SAASC;AAAAA,EACT,SAASC;AAAAA,EACT,MAAMC;AAAAA,EACN,MAAMC;AAAAA,EACN,YAAYC;AAAAA,EACZ,uBAAuBC;AAAAA,EACvB,SAASC;AAAAA,EACT,QAAQC;AAAAA,EACR,MAAMC;AAAAA,EACN,OAAOC;AAAAA,EACP,iBAAiBC;AAAAA,EACjB,QAAQC;AACV;AAOO,SAASC,GAAqBC,GAAsC;AACzE,QAAMC,IAAWD,EAAK,MAAM,GAAG,EAAE,CAAC;AAClC,SAAOf,EAAsBgB,CAAQ;AACvC;"}

package/dist/definitions/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public barrel for every definition layer.
+ *
+ * Consumers typically import from this top-level path:
+ *   import type { CardElement, DisplayCard, ShowPageConfig } from "@gxp-dev/adminkit"
+ *
+ * The engine and adapters import from `definitions/elements` /
+ * `definitions/cards` / `definitions/shared` directly to avoid pulling
+ * in the full barrel for a single type.
+ */
+export * from './shared';
+export * from './elements';
+export * from './cards';
+//# sourceMappingURL=index.d.ts.map

package/dist/definitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA"}

package/dist/definitions/shared/base.d.ts

@@ -0,0 +1,136 @@
+import { Conditional, ConditionParam } from './conditions';
+import { ResponsiveColumns } from './responsive';
+/**
+ * Union of every CardElement category — the prefix half of an
+ * element's dot-notation `type` discriminator. Each value here
+ * corresponds to one file under `definitions/elements/` and one folder
+ * under `elements/`.
+ */
+export type ElementCategory = "action" | "boolean" | "builder" | "card" | "code" | "components" | "configuration-block" | "display" | "editor" | "file" | "input" | "option-select" | "picker";
+/**
+ * Dot-notation discriminator: `"<category>.<style>"`. Combines what
+ * previously lived in two fields (`type` + `style`) into a single
+ * string so it doesn't collide with Vue's HTML `style` attribute
+ * fallthrough behaviour.
+ *
+ * Each per-category interface narrows this to its own valid styles —
+ * e.g. `InputElement["type"]` is `\`input.${InputStyle}\``.
+ */
+export type ElementType = `${ElementCategory}.${string}`;
+/**
+ * Properties common to every CardElement (input, picker, display, etc.).
+ *
+ * `type` is a `"category.style"` string. The engine's registry resolves
+ * it directly to a Vue renderer path. `name` is the form-data key for
+ * input-bearing elements.
+ */
+export interface BaseElement<TType extends ElementType = ElementType> extends Conditional, ResponsiveColumns {
+    /** Stable identifier. Required by the engine; FormBuilder generates UUIDs. */
+    id: string;
+    type: TType;
+    /** Form-data key. Required for input-bearing elements. */
+    name?: string | null;
+    label?: string;
+    /** Hide the label while keeping the element labelled for screen readers. */
+    hideLabel?: boolean;
+    defaultValue?: unknown;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    helpText?: string;
+    tooltip?: string;
+    tooltipOptions?: {
+        maxWidth?: string;
+        direction?: "top" | "right" | "bottom" | "left";
+    };
+    /** Extra classes applied to the element's root. */
+    classList?: string[] | string;
+    /** Classes on the wrapper around the element + label. */
+    wrapperClassList?: string[] | string;
+    /** Classes on the column wrapper. */
+    columnClassList?: string[] | string;
+    /** Classes on the label element. */
+    labelClassList?: string[] | string;
+    /** If true, the element renders in display-only preview mode. */
+    previewMode?: boolean;
+    /** Ordering used by builders. */
+    order?: number;
+}
+/**
+ * Union of every DisplayCard type. Mirrors the existing v2 schema.
+ */
+export type CardType = "card-list" | "tab-list" | "info-card" | "grid-view" | "element-list" | "element-display" | "datatable";
+/**
+ * Properties common to every DisplayCard (fields_list, data_table, etc.).
+ *
+ * Cards form the layout tree — they contain elements and/or other cards
+ * via `cardList` / `tabList` / `elementList` depending on `cardType`.
+ */
+export interface BaseCard<TType extends string = CardType> extends Conditional, ResponsiveColumns {
+    id: string;
+    /** Discriminator used by the engine to pick a renderer. */
+    cardType: TType;
+    title?: string;
+    subtitle?: string;
+    /** Show the surrounding chrome (border, padding). */
+    showCard?: boolean;
+    /** Wrap the card body in a Collapse with a heading. */
+    collapse?: {
+        heading?: string;
+        showingByDefault?: boolean;
+    };
+    /** Optional footer button. */
+    footerButton?: {
+        text: string;
+        route?: string;
+        icon?: string;
+    };
+    classList?: string[] | string;
+    wrapperClassList?: string[] | string;
+    order?: number;
+}
+/**
+ * Metadata used by builders / pickers to surface this element category
+ * in lists and palettes. `elementCategory` matches the prefix half of
+ * an element's dot-notation `type`.
+ */
+export interface ElementMetadata {
+    icon: string;
+    displayLabel: string;
+    elementCategory: ElementCategory;
+    description: string;
+}
+/**
+ * A single field in an EditConfig — describes how the FormBuilder
+ * inspector should render the corresponding property. It is structurally
+ * identical to a CardElement (recursive), but typed loosely here to
+ * avoid a circular reference. Stronger typing lives on the concrete
+ * inspector field shapes inside each category's file.
+ */
+export interface EditConfigField {
+    type: ElementType | string;
+    style?: string;
+    label?: string;
+    defaultValue?: unknown;
+    columns?: number;
+    columnsMd?: number;
+    columnsLg?: number;
+    section?: "configuration" | "layout" | "advanced" | "conditions" | string;
+    selectOptions?: ReadonlyArray<unknown>;
+    conditionParams?: ConditionParam[];
+    [key: string]: unknown;
+}
+export type EditConfig = Record<string, EditConfigField>;
+/**
+ * Split a dot-notation `type` back into `{ category, style }`. Useful
+ * for inspectors / debug badges that want to display the style suffix
+ * without re-parsing inline.
+ */
+export declare function splitElementType(type: string): {
+    category: ElementCategory | string;
+    style: string;
+};
+/** Build a `BaseElement["type"]` from a `(category, style)` pair. */
+export declare function joinElementType(category: ElementCategory | string, style: string): ElementType;
+//# sourceMappingURL=base.d.ts.map

package/dist/definitions/shared/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/base.ts"],"names":[],"mappings":"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"}

package/dist/definitions/shared/base.js

@@ -0,0 +1,15 @@
+function t(e) {
+  const n = e.indexOf(".");
+  return n < 0 ? { category: e, style: "" } : {
+    category: e.slice(0, n),
+    style: e.slice(n + 1)
+  };
+}
+function r(e, n) {
+  return `${e}.${n}`;
+}
+export {
+  r as joinElementType,
+  t as splitElementType
+};
+//# sourceMappingURL=base.js.map

package/dist/definitions/shared/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../src/definitions/shared/base.ts"],"sourcesContent":["import type { Conditional, ConditionParam } from \"./conditions\"\nimport type { ResponsiveColumns } from \"./responsive\"\n\n/**\n * Union of every CardElement category — the prefix half of an\n * element's dot-notation `type` discriminator. Each value here\n * corresponds to one file under `definitions/elements/` and one folder\n * under `elements/`.\n */\nexport type ElementCategory =\n  | \"action\"\n  | \"boolean\"\n  | \"builder\"\n  | \"card\"\n  | \"code\"\n  | \"components\"\n  | \"configuration-block\"\n  | \"display\"\n  | \"editor\"\n  | \"file\"\n  | \"input\"\n  | \"option-select\"\n  | \"picker\"\n\n/**\n * Dot-notation discriminator: `\"<category>.<style>\"`. Combines what\n * previously lived in two fields (`type` + `style`) into a single\n * string so it doesn't collide with Vue's HTML `style` attribute\n * fallthrough behaviour.\n *\n * Each per-category interface narrows this to its own valid styles —\n * e.g. `InputElement[\"type\"]` is `\\`input.${InputStyle}\\``.\n */\nexport type ElementType = `${ElementCategory}.${string}`\n\n/**\n * Properties common to every CardElement (input, picker, display, etc.).\n *\n * `type` is a `\"category.style\"` string. The engine's registry resolves\n * it directly to a Vue renderer path. `name` is the form-data key for\n * input-bearing elements.\n */\nexport interface BaseElement<TType extends ElementType = ElementType>\n  extends Conditional,\n    ResponsiveColumns {\n  /** Stable identifier. Required by the engine; FormBuilder generates UUIDs. */\n  id: string\n  type: TType\n  /** Form-data key. Required for input-bearing elements. */\n  name?: string | null\n  label?: string\n  /** Hide the label while keeping the element labelled for screen readers. */\n  hideLabel?: boolean\n  defaultValue?: unknown\n  required?: boolean\n  readonly?: boolean\n  disabled?: boolean\n  placeholder?: string\n  helpText?: string\n  tooltip?: string\n  tooltipOptions?: {\n    maxWidth?: string\n    direction?: \"top\" | \"right\" | \"bottom\" | \"left\"\n  }\n  /** Extra classes applied to the element's root. */\n  classList?: string[] | string\n  /** Classes on the wrapper around the element + label. */\n  wrapperClassList?: string[] | string\n  /** Classes on the column wrapper. */\n  columnClassList?: string[] | string\n  /** Classes on the label element. */\n  labelClassList?: string[] | string\n  /** If true, the element renders in display-only preview mode. */\n  previewMode?: boolean\n  /** Ordering used by builders. */\n  order?: number\n}\n\n/**\n * Union of every DisplayCard type. Mirrors the existing v2 schema.\n */\nexport type CardType =\n  | \"card-list\"\n  | \"tab-list\"\n  | \"info-card\"\n  | \"grid-view\"\n  | \"element-list\"\n  | \"element-display\"\n  | \"datatable\"\n\n/**\n * Properties common to every DisplayCard (fields_list, data_table, etc.).\n *\n * Cards form the layout tree — they contain elements and/or other cards\n * via `cardList` / `tabList` / `elementList` depending on `cardType`.\n */\nexport interface BaseCard<TType extends string = CardType>\n  extends Conditional,\n    ResponsiveColumns {\n  id: string\n  /** Discriminator used by the engine to pick a renderer. */\n  cardType: TType\n  title?: string\n  subtitle?: string\n  /** Show the surrounding chrome (border, padding). */\n  showCard?: boolean\n  /** Wrap the card body in a Collapse with a heading. */\n  collapse?: {\n    heading?: string\n    showingByDefault?: boolean\n  }\n  /** Optional footer button. */\n  footerButton?: {\n    text: string\n    route?: string\n    icon?: string\n  }\n  classList?: string[] | string\n  wrapperClassList?: string[] | string\n  order?: number\n}\n\n/**\n * Metadata used by builders / pickers to surface this element category\n * in lists and palettes. `elementCategory` matches the prefix half of\n * an element's dot-notation `type`.\n */\nexport interface ElementMetadata {\n  icon: string\n  displayLabel: string\n  elementCategory: ElementCategory\n  description: string\n}\n\n/**\n * A single field in an EditConfig — describes how the FormBuilder\n * inspector should render the corresponding property. It is structurally\n * identical to a CardElement (recursive), but typed loosely here to\n * avoid a circular reference. Stronger typing lives on the concrete\n * inspector field shapes inside each category's file.\n */\nexport interface EditConfigField {\n  type: ElementType | string\n  style?: string\n  label?: string\n  defaultValue?: unknown\n  columns?: number\n  columnsMd?: number\n  columnsLg?: number\n  section?: \"configuration\" | \"layout\" | \"advanced\" | \"conditions\" | string\n  selectOptions?: ReadonlyArray<unknown>\n  conditionParams?: ConditionParam[]\n  // Per-type extras are permitted; renderers narrow further.\n  [key: string]: unknown\n}\n\nexport type EditConfig = Record<string, EditConfigField>\n\n/**\n * Split a dot-notation `type` back into `{ category, style }`. Useful\n * for inspectors / debug badges that want to display the style suffix\n * without re-parsing inline.\n */\nexport function splitElementType(type: string): {\n  category: ElementCategory | string\n  style: string\n} {\n  const dot = type.indexOf(\".\")\n  if (dot < 0) {\n    return { category: type, style: \"\" }\n  }\n  return {\n    category: type.slice(0, dot) as ElementCategory,\n    style: type.slice(dot + 1),\n  }\n}\n\n/** Build a `BaseElement[\"type\"]` from a `(category, style)` pair. */\nexport function joinElementType(\n  category: ElementCategory | string,\n  style: string,\n): ElementType {\n  return `${category}.${style}` as ElementType\n}\n"],"names":["splitElementType","type","dot","joinElementType","category","style"],"mappings":"AAmKO,SAASA,EAAiBC,GAG/B;AACA,QAAMC,IAAMD,EAAK,QAAQ,GAAG;AAC5B,SAAIC,IAAM,IACD,EAAE,UAAUD,GAAM,OAAO,GAAA,IAE3B;AAAA,IACL,UAAUA,EAAK,MAAM,GAAGC,CAAG;AAAA,IAC3B,OAAOD,EAAK,MAAMC,IAAM,CAAC;AAAA,EAAA;AAE7B;AAGO,SAASC,EACdC,GACAC,GACa;AACb,SAAO,GAAGD,CAAQ,IAAIC,CAAK;AAC7B;"}

package/dist/definitions/shared/conditions.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Condition / visibility evaluation contract.
+ *
+ * Matches the existing v2 Mod schema:
+ *   conditionParams: [{ name: "first_name", logic: "!=", value: "" }]
+ *
+ * The engine ANDs (default) or ORs (per `conditionGroupLogic`) every
+ * entry. Nested groups are expressed by passing `subCondition: true`
+ * and providing a nested `conditionParams` array on that entry.
+ *
+ * The v1 schema used `{field, operator, value}` — the v1 adapter
+ * renames those keys before handing the element to the engine.
+ */
+export type ConditionLogic = "==" | "!=" | ">" | ">=" | "<" | "<=" | "in-array" | "not-in-array" | "starts-with" | "ends-with" | "contains" | "not-contains" | "matches" | "is-odd" | "is-even" | "is-truthy" | "is-falsy" | "is-null" | "is-not-null" | "g0length" | "n0length" | "length-eq-value" | "length-gt-value" | "length-lt-value" | "zero-length";
+export type ConditionGroupLogic = "AND" | "OR";
+export interface ConditionParam {
+    /** Dot-path into the data model. e.g. `"user.role"`. */
+    name: string;
+    logic: ConditionLogic;
+    /** Comparison value. Optional for unary operators. */
+    value?: unknown;
+    /** Type hint for `value` — "string" (literal) or "model" (data path). */
+    valueType?: "string" | "model";
+    /** When true, this entry is itself a nested group with its own params. */
+    subCondition?: boolean;
+    /** Logic for the nested group (only meaningful when subCondition). */
+    conditionGroupLogic?: ConditionGroupLogic;
+    /** Nested params (only meaningful when subCondition). */
+    conditionParams?: ConditionParam[];
+}
+export type ConditionFn<TItem = Record<string, unknown>> = (item: TItem) => boolean;
+export interface Conditional<TItem = Record<string, unknown>> {
+    /** Function predicate. Wins over `conditionParams` when both are set. */
+    condition?: ConditionFn<TItem>;
+    /** Declarative predicates, AND-combined unless `conditionGroupLogic` says OR. */
+    conditionParams?: ConditionParam[];
+    conditionGroupLogic?: ConditionGroupLogic;
+    /** Feature flags required for this element/card to render. */
+    features?: string[];
+    /** Permissions required for this element/card to render. */
+    permissions?: string[];
+}
+/**
+ * Aliases accepted by the v1 adapter. v1 JSON used `field`/`operator`;
+ * the adapter renames before evaluation.
+ */
+export interface ConditionParamV1 {
+    field: string;
+    operator: string;
+    value?: unknown;
+}
+//# sourceMappingURL=conditions.d.ts.map

package/dist/definitions/shared/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/conditions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GACtB,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,UAAU,GACV,cAAc,GACd,aAAa,GACb,WAAW,GACX,UAAU,GACV,cAAc,GACd,SAAS,GACT,QAAQ,GACR,SAAS,GACT,WAAW,GACX,UAAU,GACV,SAAS,GACT,aAAa,GACb,UAAU,GACV,UAAU,GACV,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,aAAa,CAAA;AAEjB,MAAM,MAAM,mBAAmB,GAAG,KAAK,GAAG,IAAI,CAAA;AAE9C,MAAM,WAAW,cAAc;IAC7B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,cAAc,CAAA;IACrB,sDAAsD;IACtD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,yEAAyE;IACzE,SAAS,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;IAC9B,0EAA0E;IAC1E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;IACzC,yDAAyD;IACzD,eAAe,CAAC,EAAE,cAAc,EAAE,CAAA;CACnC;AAED,MAAM,MAAM,WAAW,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CACzD,IAAI,EAAE,KAAK,KACR,OAAO,CAAA;AAEZ,MAAM,WAAW,WAAW,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1D,yEAAyE;IACzE,SAAS,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAA;IAC9B,iFAAiF;IACjF,eAAe,CAAC,EAAE,cAAc,EAAE,CAAA;IAClC,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;IACzC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB"}

package/dist/definitions/shared/connector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared connector shape used by the `integration-connector` element
+ * compositions (option-select + picker). Represents a single external
+ * integration endpoint the user can wire up — Slack workspace,
+ * Salesforce org, etc.
+ */
+export interface Connector {
+    /** Stable identifier returned by the host. */
+    id: string;
+    /** Human-facing label shown in the option list / trigger. */
+    label: string;
+    /** Optional lucide icon name (e.g. "plug", "slack", "salesforce"). */
+    icon?: string;
+    /** Display hint for the integration family. */
+    type?: string;
+    /** Current OAuth / connection status. */
+    status?: "connected" | "disconnected" | "error";
+}
+//# sourceMappingURL=connector.d.ts.map

package/dist/definitions/shared/connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/connector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,8CAA8C;IAC9C,EAAE,EAAE,MAAM,CAAA;IACV,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,GAAG,cAAc,GAAG,OAAO,CAAA;CAChD"}

package/dist/definitions/shared/crud.d.ts

@@ -0,0 +1,44 @@
+import { RouteRef } from './route';
+/**
+ * CRUD configuration shared by IndexPage / ShowPage / FormPanel.
+ * Each operation is independently optional so a page can be read-only,
+ * create-only, etc.
+ */
+export interface CreateConfig<TItem = Record<string, unknown>> {
+    create: RouteRef;
+    /**
+     * Transform the form payload before submission. Return value is what
+     * actually gets POST'd.
+     */
+    transform?: (data: TItem) => TItem | Record<string, unknown>;
+    /** Fields to reload from the server after a successful create. */
+    fieldsForceReload?: string[];
+    /** Custom button text. */
+    buttonText?: string;
+    /** Hide the create button from the UI while keeping the action wired. */
+    hideButton?: boolean;
+}
+export interface UpdateConfig<TItem = Record<string, unknown>> {
+    update: RouteRef & {
+        /** Property on the row that identifies the record (default `"id"`). */
+        key?: string;
+    };
+    /** Auto-save on field change instead of requiring an explicit save click. */
+    autoSave?: boolean;
+    /** Show or hide the explicit save button. */
+    showSaveButton?: boolean;
+    /** Run client-side validation before submitting. */
+    validation?: boolean;
+    transform?: (data: TItem) => TItem | Record<string, unknown>;
+    fieldsForceReload?: string[];
+}
+export interface DeleteConfig {
+    delete: RouteRef & {
+        key?: string;
+    };
+    /** If true, prompt the user to type a confirmation string. */
+    requiresInputConfirmation?: boolean;
+    /** Text the user must type to confirm. Default: row's display name. */
+    confirmationText?: string;
+}
+//# sourceMappingURL=crud.d.ts.map

package/dist/definitions/shared/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/crud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;GAIG;AAEH,MAAM,WAAW,YAAY,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3D,MAAM,EAAE,QAAQ,CAAA;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5D,kEAAkE;IAClE,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,0BAA0B;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,YAAY,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3D,MAAM,EAAE,QAAQ,GAAG;QACjB,uEAAuE;QACvE,GAAG,CAAC,EAAE,MAAM,CAAA;KACb,CAAA;IACD,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,6CAA6C;IAC7C,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,oDAAoD;IACpD,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5D,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,QAAQ,GAAG;QACjB,GAAG,CAAC,EAAE,MAAM,CAAA;KACb,CAAA;IACD,8DAA8D;IAC9D,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B"}

package/dist/definitions/shared/index.d.ts

@@ -0,0 +1,10 @@
+export type { BaseCard, BaseElement, CardType, EditConfig, EditConfigField, ElementCategory, ElementMetadata, ElementType, } from './base';
+export { joinElementType, splitElementType } from './base';
+export type { ConditionFn, ConditionGroupLogic, ConditionLogic, ConditionParam, ConditionParamV1, Conditional, } from './conditions';
+export type { Connector } from './connector';
+export type { CreateConfig, DeleteConfig, UpdateConfig } from './crud';
+export type { ResponsiveColumns, ResponsiveColumnsKey, ResponsiveColumnsV1, } from './responsive';
+export type { HttpMethod, RouteRef } from './route';
+export type { SelectOption, SelectOptionLike, SelectOptionsResolver, } from './select-options';
+export type { ValidationConfig, ValidationRule } from './validation';
+//# sourceMappingURL=index.d.ts.map

package/dist/definitions/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,UAAU,EACV,eAAe,EACf,eAAe,EACf,eAAe,EACf,WAAW,GACZ,MAAM,QAAQ,CAAA;AACf,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA;AAC1D,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,GACZ,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACtE,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AACnD,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/dist/definitions/shared/responsive.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Bootstrap-style responsive grid props shared across every card and
+ * element. The numbers match a 12-column grid (`columns: 6` = half width).
+ *
+ * Naming mirrors the existing v2 Mod schema exactly so JSON authored
+ * against the experience-portal renders without translation.
+ */
+export interface ResponsiveColumns {
+    /** Default span (mobile-first, all breakpoints). */
+    columns?: number;
+    /** Span at >= 576px. */
+    columnsSm?: number;
+    /** Span at >= 768px. */
+    columnsMd?: number;
+    /** Span at >= 992px. */
+    columnsLg?: number;
+    /** Span at >= 1200px. */
+    columnsXl?: number;
+    /** Span at >= 1400px. */
+    columnsXxl?: number;
+}
+export type ResponsiveColumnsKey = keyof ResponsiveColumns;
+/**
+ * Aliases accepted by the v1 adapter. v1 JSON uses `cols/colsMd/...`;
+ * the adapter maps these to the v2 keys above.
+ */
+export interface ResponsiveColumnsV1 {
+    cols?: number;
+    colsSm?: number;
+    colsMd?: number;
+    colsLg?: number;
+    colsXl?: number;
+    colsXxl?: number;
+}
+//# sourceMappingURL=responsive.d.ts.map

package/dist/definitions/shared/responsive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responsive.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/responsive.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,yBAAyB;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,iBAAiB,CAAA;AAE1D;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB"}

package/dist/definitions/shared/route.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Route reference used by data-driven cards (DataTable, AsyncSelect, etc.)
+ * and CRUD config. Matches the Laravel-named-route convention used by the
+ * GxP platform: `{ route: 'api.users.index', params: {team: 'current'} }`.
+ */
+export type HttpMethod = "get" | "post" | "put" | "patch" | "delete" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface RouteRef {
+    /** Laravel-named route or a raw URL starting with `/`. */
+    route: string;
+    /** Path / query params injected into the route. */
+    params?: Record<string, unknown>;
+    /** HTTP verb; defaults to `get`. */
+    requestType?: HttpMethod;
+    /** Override the body for POST-style routes. */
+    data?: Record<string, unknown>;
+    /** Extra headers to merge into the request. */
+    headers?: Record<string, string>;
+}
+//# sourceMappingURL=route.d.ts.map

package/dist/definitions/shared/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/route.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAClB,KAAK,GACL,MAAM,GACN,KAAK,GACL,OAAO,GACP,QAAQ,GACR,KAAK,GACL,MAAM,GACN,KAAK,GACL,OAAO,GACP,QAAQ,CAAA;AAEZ,MAAM,WAAW,QAAQ;IACvB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAA;IACb,mDAAmD;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,oCAAoC;IACpC,WAAW,CAAC,EAAE,UAAU,CAAA;IACxB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC"}

package/dist/definitions/shared/select-options.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Common option / choice shapes shared by every selectable element
+ * (option-select, picker, etc.). The shape mirrors the v2 schema so
+ * JSON authored against the platform deserialises cleanly.
+ */
+export interface SelectOption<TValue = unknown> {
+    label: string;
+    value: TValue;
+    /** Secondary text rendered beneath / beside the label. */
+    secondaryText?: string;
+    /** Inline icon name (lucide). */
+    icon?: string;
+    /** Optional Tailwind class or style hint. */
+    className?: string;
+    disabled?: boolean;
+    /** Free-form metadata consumers can use; ignored by the renderer. */
+    meta?: Record<string, unknown>;
+}
+/** A plain string option is also accepted by the engine. */
+export type SelectOptionLike<TValue = unknown> = SelectOption<TValue> | string;
+/**
+ * Functions that resolve options dynamically from the bound data model.
+ * Lets a select compute its options from sibling fields without a
+ * round-trip to the server.
+ */
+export type SelectOptionsResolver<TItem = Record<string, unknown>, TValue = unknown> = (item: TItem) => SelectOptionLike<TValue>[];
+//# sourceMappingURL=select-options.d.ts.map

package/dist/definitions/shared/select-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-options.d.ts","sourceRoot":"","sources":["../../../src/definitions/shared/select-options.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,MAAM,GAAG,OAAO;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED,4DAA4D;AAC5D,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,OAAO,IAAI,YAAY,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;AAE9E;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,IAAI,CACrF,IAAI,EAAE,KAAK,KACR,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAA"}