@furo/open-models 1.14.0 → 1.15.0

package/custom-elements.json

@@ -1209,6 +1209,271 @@
       "declarations": [],
       "exports": []
     },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/EntityServiceTypes.js",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/EntityServiceTypes.js.map",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/FieldBindings.js",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "fieldBindings",
+          "type": {
+            "text": "object"
+          },
+          "default": "{ /** * Decorator for the `model` property. * * Handles: * - Binding/unbinding when model changes * - Resolving reader/writer functions based on model type * - Calling reader on model value changes * - Providing `writeToModel()` method */ model() { return function modelDecorator(target, propertyKey) { const ctor = target.constructor; // Patch lifecycle patchLifecycle(ctor); // Add writeToModel helper method if (!Object.prototype.hasOwnProperty.call(target, \"writeToModel\")) { Object.defineProperty(target, \"writeToModel\", { value: function writeToModel() { const writeFn = this[MODEL_WRITE_FN]; if (writeFn) { try { writeFn(); } catch (e) { // eslint-disable-next-line no-console console.error(\"Failed to write to model:\", e); } } }, writable: false, enumerable: false, configurable: true, }); } // Create getter/setter for the model property Object.defineProperty(target, propertyKey, { get() { return this[CURRENT_MODEL]; }, set(value) { const oldModel = this[CURRENT_MODEL]; if (value === oldModel) return; // Unbind from old model if (oldModel) { unbindFromModel(this, oldModel); } // Store new model this[CURRENT_MODEL] = value; // Resolve reader/writer functions based on type if (value) { const typeName = value.__meta?.typeName ?? \"primitives.STRING\"; // Resolve reader const reader = this.modelReaders?.get(typeName); if (reader) { this[MODEL_READ_FN] = reader.bind(this); } else { // eslint-disable-next-line no-console console.warn(`No modelReader for type \"${typeName}\". Available: ${[...(this.modelReaders?.keys() ?? [])].join(\", \")}`); this[MODEL_READ_FN] = undefined; } // Resolve writer const writer = this.modelWriters?.get(typeName); if (writer) { this[MODEL_WRITE_FN] = writer.bind(this); } else { // eslint-disable-next-line no-console console.warn(`No modelWriter for type \"${typeName}\". Available: ${[...(this.modelWriters?.keys() ?? [])].join(\", \")}`); this[MODEL_WRITE_FN] = undefined; } } else { this[MODEL_READ_FN] = undefined; this[MODEL_WRITE_FN] = undefined; } // Bind to new model (if connected) if (value && this.isConnected) { bindToModel(this, value); } // Trigger Lit update this.requestUpdate(); }, enumerable: true, configurable: true, }); }; }, /** * Binds a method to an event on the model. * When the event fires, the method is called with the event detail. * * @param eventType - The event type to listen for */ onEvent(eventType) { return function onEventDecorator(target, propertyKey, descriptor) { const originalMethod = descriptor.value; const ctor = target.constructor; let events = ctor[FIELD_EVENTS]; if (!events) { events = []; ctor[FIELD_EVENTS] = events; } events.push({ propertyKey, eventType, method: originalMethod }); patchLifecycle(ctor); }; }, }",
+          "description": "### fieldBindings\n\nDecorators for creating reusable components that bind to FieldNode models.\n\nThe component provides `modelReaders` and `modelWriters` maps keyed by\n`__meta.typeName`. The decorator handles:\n- Binding/unbinding on model change\n- Calling the correct reader when model value changes\n- Providing `writeToModel()` method that calls the correct writer"
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "fieldBindings",
+          "declaration": {
+            "name": "fieldBindings",
+            "module": "dist/decorators/FieldBindings.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/FieldBindings.js.map",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/ModelDecorators.js",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "modelBindings",
+          "parameters": [
+            {
+              "name": "model",
+              "description": "The FieldNode model to bind to"
+            }
+          ],
+          "description": "### modelBindings Factory\n\nCreates type-safe decorators bound to a specific FieldNode model.\nUse this to bind component properties and methods to model events.\n\nUsage:\n```typescript\nimport { modelBindings } from \"@x/furo/open-models/ModelDecorators\";\nimport { CubeEntityModel } from \"./CubeEntityModel\";\n\nconst cubeModel = modelBindings(CubeEntityModel.model);\n\nclass MyComponent extends LitElement {\n  // Bind to a nested field value - updates when cube.length changes",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "modelBindings",
+          "declaration": {
+            "name": "modelBindings",
+            "module": "dist/decorators/ModelDecorators.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/ModelDecorators.js.map",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/SchemaBuilder.js",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "",
+          "name": "SchemaBuilder",
+          "members": [
+            {
+              "kind": "method",
+              "name": "generate",
+              "static": true,
+              "parameters": [
+                {
+                  "name": "model"
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getProps",
+              "static": true,
+              "parameters": [
+                {
+                  "name": "model"
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getRequiredFields",
+              "static": true,
+              "parameters": [
+                {
+                  "name": "descriptors"
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "getConstraints",
+              "static": true,
+              "parameters": [
+                {
+                  "name": "constraints"
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "createFieldNodeFromSchema",
+              "static": true,
+              "parameters": [
+                {
+                  "name": "schema"
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "SchemaBuilder",
+          "declaration": {
+            "name": "SchemaBuilder",
+            "module": "dist/decorators/SchemaBuilder.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/SchemaBuilder.js.map",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/ServiceDecorators.js",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "serviceBindings",
+          "parameters": [
+            {
+              "name": "service",
+              "description": "The EventTarget service to bind to"
+            }
+          ],
+          "description": "### serviceBindings Factory\n\nCreates type-safe decorators bound to a specific service instance.\nUse this to bind component properties and methods to service events.\n\nThe factory is generic and works with any `EventTarget`.\nEvent types and their detail payloads are type-checked at compile time\nvia the `TEventMap` type parameter.\n\nUsage:\n```typescript\nimport { cubeEntityService } from \"./CubeEntityService\";\nimport { serviceBindings } from \"./ServiceDecorators.js\";\n\nconst cube = serviceBindings(cubeEntityService);\n\nclass MyComponent extends LitElement {\n  // Property binding - type-safe event name, auto-extracts from detail",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "serviceBindings",
+          "declaration": {
+            "name": "serviceBindings",
+            "module": "dist/decorators/ServiceDecorators.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/ServiceDecorators.js.map",
+      "declarations": [],
+      "exports": []
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/defaultServiceEventHandlers.js",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "defaultServiceEventHandlers",
+          "parameters": [
+            {
+              "name": "dispatch",
+              "description": "Function to dispatch events (typically bound to the service's dispatchEvent)"
+            },
+            {
+              "name": "options",
+              "default": "{}",
+              "description": "Optional configuration"
+            }
+          ],
+          "description": "### defaultServiceEventHandlers\n\nCreates default service handlers that dispatch standard events.\nUse this to reduce boilerplate when setting up service handlers.\n\nThe `onResponse` handler is intentionally NOT included - you must provide your own\nimplementation since response handling is typically service-specific.\n\nUsage:\n```typescript\nclass MyEntityService extends EventTarget {\n  private dispatch = createDispatch(this);\n\n  setupHandlers() {\n    this.service.Get.setHandlers({\n      ...defaultServiceEventHandlers(this.dispatch),\n      onResponse: (response, serverResponse) => {\n        // Your custom response handling\n        this.entity.fromLiteral(response.entity);\n        this.dispatch(\"response-received\", { response, serverResponse });\n      },\n    });\n  }\n}\n```\n\nWith loading check:\n```typescript\nthis.service.Get.setHandlers({\n  ...defaultServiceEventHandlers(this.dispatch, {\n    isLoading: () => this.service.Get.isLoading || this.service.Update.isLoading,\n  }),\n  onResponse: (response, serverResponse) => { ... },\n});\n```",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          }
+        },
+        {
+          "kind": "function",
+          "name": "createDispatch",
+          "parameters": [
+            {
+              "name": "target",
+              "description": "The EventTarget to dispatch events on"
+            }
+          ],
+          "description": "### createDispatch\n\nHelper to create a typed dispatch function for an EventTarget.\n\nUsage:\n```typescript\nclass MyService extends EventTarget {\n  private dispatch = createDispatch(this);\n\n  doSomething() {\n    this.dispatch(\"busy-changed\", { busy: true });\n  }\n}\n```",
+          "return": {
+            "type": {
+              "text": ""
+            }
+          }
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "defaultServiceEventHandlers",
+          "declaration": {
+            "name": "defaultServiceEventHandlers",
+            "module": "dist/decorators/defaultServiceEventHandlers.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createDispatch",
+          "declaration": {
+            "name": "createDispatch",
+            "module": "dist/decorators/defaultServiceEventHandlers.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "dist/decorators/defaultServiceEventHandlers.js.map",
+      "declarations": [],
+      "exports": []
+    },
     {
       "kind": "javascript-module",
       "path": "dist/index.js",
@@ -1501,6 +1766,54 @@
             "name": "RECURSION",
             "module": "./proxies/RECURSION.js"
           }
+        },
+        {
+          "kind": "js",
+          "name": "serviceBindings",
+          "declaration": {
+            "name": "serviceBindings",
+            "module": "./decorators/ServiceDecorators.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "modelBindings",
+          "declaration": {
+            "name": "modelBindings",
+            "module": "./decorators/ModelDecorators.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "fieldBindings",
+          "declaration": {
+            "name": "fieldBindings",
+            "module": "./decorators/FieldBindings.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "SchemaBuilder",
+          "declaration": {
+            "name": "SchemaBuilder",
+            "module": "./decorators/SchemaBuilder.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "defaultServiceEventHandlers",
+          "declaration": {
+            "name": "defaultServiceEventHandlers",
+            "module": "./decorators/defaultServiceEventHandlers.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "createDispatch",
+          "declaration": {
+            "name": "createDispatch",
+            "module": "./decorators/defaultServiceEventHandlers.js"
+          }
         }
       ]
     },

package/dist/decorators/EntityServiceTypes.d.ts

@@ -0,0 +1,133 @@
+/**
+ * ### EntityServiceEventType
+ *
+ * Standard event types dispatched by entity services.
+ * These events cover the full lifecycle of REST API operations.
+ *
+ * #### Request Lifecycle Events
+ * | Event              | Description                                           |
+ * |--------------------|-------------------------------------------------------|
+ * | `busy-changed`     | Loading/saving state changed                          |
+ * | `request-started`  | Request has been initiated                            |
+ * | `request-finished` | Request completed (success, error, or abort)          |
+ * | `request-aborted`  | Request was aborted (navigation, timeout, new request)|
+ *
+ * #### Success Events
+ * | Event              | Description                                           |
+ * |--------------------|-------------------------------------------------------|
+ * | `response-received`| Successful response with parsed data                  |
+ * | `raw-response`     | Successful response (raw, before parsing)             |
+ *
+ * #### Error Events
+ * | Event              | Description                                           |
+ * |--------------------|-------------------------------------------------------|
+ * | `response-error`   | Any error response (4xx/5xx) with parsed body         |
+ * | `raw-error`        | Any error response (raw, before parsing)              |
+ * | `error-404`        | Resource not found (404)                              |
+ * | `error-5xx`        | Server error (500+)                                   |
+ * | `fatal-error`      | Unhandled/unexpected error                            |
+ *
+ * Usage:
+ * ```typescript
+ * export type MyServiceEventType = EntityServiceEventType;
+ * // Or extend with custom events:
+ * export type MyServiceEventType = EntityServiceEventType | "custom-event";
+ * ```
+ */
+export type EntityServiceEventType = "busy-changed" | "request-started" | "request-finished" | "request-aborted" | "response-received" | "raw-response" | "response-error" | "raw-error" | "error-404" | "error-5xx" | "fatal-error";
+/**
+ * ### EntityServiceEventMap
+ *
+ * Maps each event type to its detail payload type.
+ * This enables type-safe event handling with `storeBindings`.
+ *
+ * #### Request Lifecycle Events
+ * | Event              | Detail Type                                      |
+ * |--------------------|--------------------------------------------------|
+ * | `busy-changed`     | `{ busy: boolean }`                              |
+ * | `request-started`  | `{ request: unknown }`                           |
+ * | `request-finished` | `{ request: unknown }`                           |
+ * | `request-aborted`  | `{ reason: string }`                             |
+ *
+ * #### Success Events
+ * | Event              | Detail Type                                      |
+ * |--------------------|--------------------------------------------------|
+ * | `response-received`| `{ response: unknown, serverResponse: Response }`|
+ * | `raw-response`     | `{ serverResponse: Response }`                   |
+ *
+ * #### Error Events
+ * | Event              | Detail Type                                      |
+ * |--------------------|--------------------------------------------------|
+ * | `response-error`   | `{ parsedResponse: unknown, serverResponse: Response }` |
+ * | `raw-error`        | `{ serverResponse: Response }`                   |
+ * | `error-404`        | `{ serverResponse: Response }`                   |
+ * | `error-5xx`        | `{ serverResponse: Response }`                   |
+ * | `fatal-error`      | `{ error: unknown }`                             |
+ *
+ * Usage:
+ * ```typescript
+ * // Extend with custom events:
+ * interface MyServiceEventMap extends EntityServiceEventMap {
+ *   "custom-event": { data: string };
+ * }
+ * ```
+ */
+export interface EntityServiceEventMap {
+    "busy-changed": {
+        busy: boolean;
+    };
+    "request-started": {
+        request: unknown;
+    };
+    "request-finished": {
+        request: unknown;
+    };
+    "request-aborted": {
+        reason: string;
+    };
+    "response-received": {
+        response: unknown;
+        serverResponse: Response;
+    };
+    "raw-response": {
+        serverResponse: Response;
+    };
+    "response-error": {
+        parsedResponse: unknown;
+        serverResponse: Response;
+    };
+    "raw-error": {
+        serverResponse: Response;
+    };
+    "error-404": {
+        serverResponse: Response;
+    };
+    "error-5xx": {
+        serverResponse: Response;
+    };
+    "fatal-error": {
+        error: unknown;
+    };
+}
+/**
+ * ### TypedEntityService
+ *
+ * Type alias for entity services with type-safe event handling.
+ * Use this when you need to type a variable or parameter that holds a service.
+ *
+ * Note: Services extend `EventTarget` at runtime, but this type provides
+ * compile-time type safety for event names when used with `storeBindings`.
+ *
+ * Usage:
+ * ```typescript
+ * // Type a variable
+ * const service: TypedEntityService = cubeEntityService;
+ *
+ * // With custom events
+ * interface MyEventMap extends EntityServiceEventMap {
+ *   "custom-event": { data: string };
+ * }
+ * const myService: TypedEntityService<MyEventMap> = myEntityService;
+ * ```
+ */
+export type TypedEntityService<_TEventMap extends EntityServiceEventMap = EntityServiceEventMap> = EventTarget;

package/dist/decorators/EntityServiceTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EntityServiceTypes.js.map

package/dist/decorators/EntityServiceTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntityServiceTypes.js","sourceRoot":"","sources":["../../src/decorators/EntityServiceTypes.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * ### EntityServiceEventType\n *\n * Standard event types dispatched by entity services.\n * These events cover the full lifecycle of REST API operations.\n *\n * #### Request Lifecycle Events\n * | Event              | Description                                           |\n * |--------------------|-------------------------------------------------------|\n * | `busy-changed`     | Loading/saving state changed                          |\n * | `request-started`  | Request has been initiated                            |\n * | `request-finished` | Request completed (success, error, or abort)          |\n * | `request-aborted`  | Request was aborted (navigation, timeout, new request)|\n *\n * #### Success Events\n * | Event              | Description                                           |\n * |--------------------|-------------------------------------------------------|\n * | `response-received`| Successful response with parsed data                  |\n * | `raw-response`     | Successful response (raw, before parsing)             |\n *\n * #### Error Events\n * | Event              | Description                                           |\n * |--------------------|-------------------------------------------------------|\n * | `response-error`   | Any error response (4xx/5xx) with parsed body         |\n * | `raw-error`        | Any error response (raw, before parsing)              |\n * | `error-404`        | Resource not found (404)                              |\n * | `error-5xx`        | Server error (500+)                                   |\n * | `fatal-error`      | Unhandled/unexpected error                            |\n *\n * Usage:\n * ```typescript\n * export type MyServiceEventType = EntityServiceEventType;\n * // Or extend with custom events:\n * export type MyServiceEventType = EntityServiceEventType | \"custom-event\";\n * ```\n */\nexport type EntityServiceEventType =\n  // Request lifecycle\n  | \"busy-changed\"\n  | \"request-started\"\n  | \"request-finished\"\n  | \"request-aborted\"\n  // Success\n  | \"response-received\"\n  | \"raw-response\"\n  // Errors\n  | \"response-error\"\n  | \"raw-error\"\n  | \"error-404\"\n  | \"error-5xx\"\n  | \"fatal-error\";\n\n/**\n * ### EntityServiceEventMap\n *\n * Maps each event type to its detail payload type.\n * This enables type-safe event handling with `storeBindings`.\n *\n * #### Request Lifecycle Events\n * | Event              | Detail Type                                      |\n * |--------------------|--------------------------------------------------|\n * | `busy-changed`     | `{ busy: boolean }`                              |\n * | `request-started`  | `{ request: unknown }`                           |\n * | `request-finished` | `{ request: unknown }`                           |\n * | `request-aborted`  | `{ reason: string }`                             |\n *\n * #### Success Events\n * | Event              | Detail Type                                      |\n * |--------------------|--------------------------------------------------|\n * | `response-received`| `{ response: unknown, serverResponse: Response }`|\n * | `raw-response`     | `{ serverResponse: Response }`                   |\n *\n * #### Error Events\n * | Event              | Detail Type                                      |\n * |--------------------|--------------------------------------------------|\n * | `response-error`   | `{ parsedResponse: unknown, serverResponse: Response }` |\n * | `raw-error`        | `{ serverResponse: Response }`                   |\n * | `error-404`        | `{ serverResponse: Response }`                   |\n * | `error-5xx`        | `{ serverResponse: Response }`                   |\n * | `fatal-error`      | `{ error: unknown }`                             |\n *\n * Usage:\n * ```typescript\n * // Extend with custom events:\n * interface MyServiceEventMap extends EntityServiceEventMap {\n *   \"custom-event\": { data: string };\n * }\n * ```\n */\nexport interface EntityServiceEventMap {\n  // Request lifecycle\n  \"busy-changed\": { busy: boolean };\n  \"request-started\": { request: unknown };\n  \"request-finished\": { request: unknown };\n  \"request-aborted\": { reason: string };\n  // Success\n  \"response-received\": { response: unknown; serverResponse: Response };\n  \"raw-response\": { serverResponse: Response };\n  // Errors\n  \"response-error\": { parsedResponse: unknown; serverResponse: Response };\n  \"raw-error\": { serverResponse: Response };\n  \"error-404\": { serverResponse: Response };\n  \"error-5xx\": { serverResponse: Response };\n  \"fatal-error\": { error: unknown };\n}\n\n/**\n * ### TypedEntityService\n *\n * Type alias for entity services with type-safe event handling.\n * Use this when you need to type a variable or parameter that holds a service.\n *\n * Note: Services extend `EventTarget` at runtime, but this type provides\n * compile-time type safety for event names when used with `storeBindings`.\n *\n * Usage:\n * ```typescript\n * // Type a variable\n * const service: TypedEntityService = cubeEntityService;\n *\n * // With custom events\n * interface MyEventMap extends EntityServiceEventMap {\n *   \"custom-event\": { data: string };\n * }\n * const myService: TypedEntityService<MyEventMap> = myEntityService;\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport type TypedEntityService<_TEventMap extends EntityServiceEventMap = EntityServiceEventMap> = EventTarget;\n"]}

package/dist/decorators/FieldBindings.d.ts

@@ -0,0 +1,104 @@
+import { LitElement } from "lit";
+import type { ModelEventType } from "./ModelDecorators.js";
+/**
+ * Interface for FieldNode-like objects that support event listening.
+ */
+export interface FieldNodeLike {
+    __addEventListener(type: string, listener: (e: CustomEvent) => void): void;
+    __removeEventListener(type: string, listener: (e: CustomEvent) => void): void;
+    __meta?: {
+        typeName?: string;
+    };
+    value?: unknown;
+}
+/**
+ * Interface for components that bind to FieldNode models.
+ *
+ * Components implement `modelReaders` and `modelWriters` maps
+ * keyed by `__meta.typeName` (e.g., "primitives.STRING", "furo.fat.String").
+ *
+ * @example
+ * ```typescript
+ * export class MyInput extends LitElement implements BindableComponent {
+ *   @fieldBindings.model()
+ *   model: STRING | XString | undefined;
+ *
+ *   // Provided by decorator
+ *   declare writeToModel: () => void;
+ *
+ *   modelReaders = new Map<string, () => void>([
+ *     ["primitives.STRING", () => { this.value = (this.model as STRING).value ?? ""; }],
+ *     ["furo.fat.String", () => { this.value = (this.model as XString).value.value ?? ""; }],
+ *   ]);
+ *
+ *   modelWriters = new Map<string, () => void>([
+ *     ["primitives.STRING", () => { (this.model as STRING).value = this.value; }],
+ *     ["furo.fat.String", () => { (this.model as XString).value.value = this.value; }],
+ *   ]);
+ * }
+ * ```
+ */
+export interface BindableComponent extends LitElement {
+    model: FieldNodeLike | undefined;
+    /** Map of typeName → reader function (model → component) */
+    modelReaders: Map<string, () => void>;
+    /** Map of typeName → writer function (component → model) */
+    modelWriters: Map<string, () => void>;
+    /** Helper to write current value to model (provided by decorator) */
+    writeToModel: () => void;
+}
+/**
+ * ### fieldBindings
+ *
+ * Decorators for creating reusable components that bind to FieldNode models.
+ *
+ * The component provides `modelReaders` and `modelWriters` maps keyed by
+ * `__meta.typeName`. The decorator handles:
+ * - Binding/unbinding on model change
+ * - Calling the correct reader when model value changes
+ * - Providing `writeToModel()` method that calls the correct writer
+ *
+ * @example
+ * ```typescript
+ * export class MyInput extends LitElement implements BindableComponent {
+ *   @fieldBindings.model()
+ *   model: STRING | XString | undefined;
+ *
+ *   declare writeToModel: () => void;
+ *
+ *   modelReaders = new Map([
+ *     ["primitives.STRING", () => { this.value = (this.model as STRING).value ?? ""; }],
+ *     ["furo.fat.String", () => { this.value = (this.model as XString).value.value ?? ""; }],
+ *   ]);
+ *
+ *   modelWriters = new Map([
+ *     ["primitives.STRING", () => { (this.model as STRING).value = this.value; }],
+ *     ["furo.fat.String", () => { (this.model as XString).value.value = this.value; }],
+ *   ]);
+ *
+ *   private _onInput(e: Event) {
+ *     this.value = (e.target as HTMLInputElement).value;
+ *     this.writeToModel();
+ *   }
+ * }
+ * ```
+ */
+export declare const fieldBindings: {
+    /**
+     * Decorator for the `model` property.
+     *
+     * Handles:
+     * - Binding/unbinding when model changes
+     * - Resolving reader/writer functions based on model type
+     * - Calling reader on model value changes
+     * - Providing `writeToModel()` method
+     */
+    model(): <T extends FieldNodeLike>(target: object, propertyKey: string) => void;
+    /**
+     * Binds a method to an event on the model.
+     * When the event fires, the method is called with the event detail.
+     *
+     * @param eventType - The event type to listen for
+     */
+    onEvent(eventType: ModelEventType): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => void;
+};