@synapcores/openclaw-memory 0.1.0 → 0.3.0

package/README.md

@@ -2,12 +2,11 @@
 
 A long-term memory plugin for [OpenClaw](https://github.com/openclaw/openclaw) that uses **SynapCores AIDB** as the storage backend. Drop-in alternative to `@openclaw/memory-lancedb` with the same auto-recall / auto-capture lifecycle, plus three SynapCores-only extensions: SQL-filtered semantic recall, graph-relation walks, and AutoML relevance scoring.
 
-> **0.1.0 shipping note:** tested against gateway `v1.6.5.2-ce` and `@synapcores/sdk@0.3.0`. The parity API (recall/capture/forget) plus two of the three SynapCores-only read extensions (`recallFiltered`, `predictRelevance`) are wired against the live SDK and exercised end-to-end. Two methods are **signature-only in 0.1.0** and throw a clear "ships in 0.2.0" error before calling the gateway:
+> **0.2.0 shipping note:** verified against gateway `v1.6.5.2-ce` and `@synapcores/sdk@^0.4.0`. The full surface — parity API (recall/capture/forget) **plus all four SynapCores-only extensions** (`recallFiltered`, `recallRelated`, `predictRelevance`, `trainRelevanceModel`) — is wired against the live SDK and exercised end-to-end (7/7 live smoke steps pass against `:28201`).
 >
-> - **`trainRelevanceModel`** — gateway `v1.6.5.x` rejects inline training data with HTTP 400; 0.2.0 stages rows in a sibling collection before calling `/v1/automl/train`. `predictRelevance` runs in heuristic mode in the meantime (always works).
-> - **`recallRelated`** — gateway `v1.6.5.x` derives `SIMILAR_TO` synthetically from a graph-node vector index that this release does not populate (the plugin writes only to the vector collection; promoting Memory nodes into the graph backend ships in 0.2.0). Use `predictRelevance(query, candidates)` over a broad `recallFiltered({where: "1=1", semantic: query, limit: 20})` for relevance-scoped recall in the meantime.
->
-> `autoLinkSimilar` is also a no-op in 0.1.0 for the same synthetic-edge reason (the gateway doesn't permit explicit `MERGE`s on `SIMILAR_TO` and computes the edge from vectors at query time).
+> - **`recallRelated`** is now implemented (was signature-only in 0.1.0). On capture, the plugin inserts each Memory as a graph node carrying the embedding under the `embedding` property so the gateway's synthetic `SIMILAR_TO` edge resolves at MATCH time. `autoLinkSimilar: true` (default) enables this; turn it off if you don't need graph-backed recall.
+> - **`trainRelevanceModel`** is now implemented (was signature-only in 0.1.0). Feedback rows are staged in a SQL table (`openclaw_memory_relevance_training[_<workspace>]`) the gateway's AutoML can read, then trained as a regression model targeting the `score` column.
+> - SDK dep bumped to `@synapcores/sdk@^0.4.0` (which switched API-key auth to `Authorization: Bearer` and added `createVectorCollection` / `vectorCollection(name)`). The three v0.1.0 workarounds — auth-header shim, direct `/v1/vectors/collections` POSTs, direct `/v1/vectors/collections/{n}/vectors` POSTs — are deleted in favour of the SDK's typed helpers.
 
 ## Why use this over `@openclaw/memory-lancedb`?
 
@@ -48,33 +47,58 @@ Create an API key from the SynapCores admin UI (default `http://localhost:8095`)
 
 ## Configure
 
-Add this entry to your `openclaw.config.json` (or whichever config path your OpenClaw install uses):
+Requires OpenClaw **`>=2026.4.10`**. Install the plugin, then add its config and
+give it the **memory slot**:
+
+```bash
+openclaw plugins install @synapcores/openclaw-memory
+```
+
+Add this to your OpenClaw config (run `openclaw config file` to find the path,
+typically `~/.openclaw/openclaw.json`). Three things matter: the
+`plugins.entries.<id>.config` nesting, the `plugins.allow` entry, and
+**`plugins.slots.memory`**:
 
 ```json
 {
   "plugins": {
-    "memory-synapcores": {
-      "embedding": {
-        "apiKey": "${OPENAI_API_KEY}",
-        "model": "text-embedding-3-small"
-      },
-      "synapcores": {
-        "host": "localhost",
-        "port": 8080,
-        "apiKey": "${SYNAPCORES_API_KEY}",
-        "useHttps": false
-      },
-      "collection": "openclaw_memories",
-      "graph": "openclaw_memory_graph",
-      "autoCapture": true,
-      "autoRecall": true,
-      "autoLinkSimilar": true
+    "allow": ["memory-synapcores"],
+    "slots": { "memory": "memory-synapcores" },
+    "entries": {
+      "memory-synapcores": {
+        "enabled": true,
+        "config": {
+          "embedding": {
+            "apiKey": "${OPENAI_API_KEY}",
+            "model": "text-embedding-3-small"
+          },
+          "synapcores": {
+            "host": "localhost",
+            "port": 8080,
+            "apiKey": "${SYNAPCORES_API_KEY}",
+            "useHttps": false
+          },
+          "collection": "openclaw_memories",
+          "graph": "openclaw_memory_graph",
+          "autoCapture": true,
+          "autoRecall": true,
+          "autoLinkSimilar": true
+        }
+      }
     }
   }
 }
 ```
 
-Environment-variable interpolation (`${OPENAI_API_KEY}`, `${SYNAPCORES_API_KEY}`) is supported in any string field so you don't have to commit secrets.
+> **You must set `plugins.slots.memory` to `"memory-synapcores"`.** Only one
+> plugin can own the memory slot, and the default is OpenClaw's built-in
+> `memory-core` — without claiming the slot the plugin loads but stays
+> **disabled**.
+
+Then `openclaw config validate`. Environment-variable interpolation
+(`${OPENAI_API_KEY}`, `${SYNAPCORES_API_KEY}`) is supported in any string field
+so you don't have to commit secrets. (Store keys **clean** — a trailing newline
+in `apiKey` will break auth.)
 
 ### Config fields
 
@@ -90,7 +114,7 @@ Environment-variable interpolation (`${OPENAI_API_KEY}`, `${SYNAPCORES_API_KEY}`
 | `graph` | no | `openclaw_memory_graph` | SynapCores graph name (used for `SIMILAR_TO` edges and `recallRelated` walks). |
 | `autoCapture` | no | `true` | Auto-store memorable utterances after each agent turn. |
 | `autoRecall` | no | `true` | Auto-inject relevant memories before each agent turn. |
-| `autoLinkSimilar` | no | `true` | On capture, draw `SIMILAR_TO` edges to existing memories with cosine similarity > 0.7 so `recallRelated` returns useful neighborhoods out of the box (adds ~30-50ms per capture). |
+| `autoLinkSimilar` | no | `true` | On capture, insert each Memory as a graph node carrying the embedding so `recallRelated` returns useful neighborhoods out of the box. Adds ~30-80ms per capture; disable if you never call `recallRelated`. |
 | `workspace` | no | — | Optional workspace suffix on the AutoML relevance model name so multiple installations sharing one gateway can train independent models. |
 
 ## What you get
@@ -160,12 +184,16 @@ The `where` clause is forwarded to the SynapCores gateway as the `filter` field
 
 ```ts
 const neighbors = await plugin.extensions.recallRelated(memoryId, {
-  hops: 2,
-  edgeKinds: ["SIMILAR_TO"], // omit for any edge type
+  hops: 1,
+  edgeKinds: ["SIMILAR_TO"],   // default
+  similarityThreshold: 0.5,    // default — cosine threshold for synthetic edges
+  limit: 20,
 });
 ```
 
-> **0.1.0 status:** this method validates its arguments and throws a clear "ships in 0.2.0" error before calling the gateway. Gateway `v1.6.5.x` derives `SIMILAR_TO` edges synthetically from a graph-node vector index that the plugin does not populate in this release; 0.2.0 will post each Memory node into the graph backend with its embedding at capture time so the gateway's `[:SIMILAR_TO > T]` MATCH expansion returns useful neighborhoods. Wire your callers now and they will start returning data the moment you upgrade to `@synapcores/openclaw-memory@0.2.0`.
+Returns memories cosine-similar to the source (synthetic `SIMILAR_TO` edges, single-hop), plus any explicit `MENTIONS` / `RELATES_TO` edges the caller has populated (multi-hop supported on non-synthetic edge kinds). Requires `autoLinkSimilar: true` at capture time — the plugin inserts each Memory as a graph node carrying the embedding so the gateway's vector-indexed synthetic edges resolve at MATCH time.
+
+If a source memory was captured before `autoLinkSimilar` was enabled, its `Memory` graph node won't exist and `recallRelated` will return `[]` for it. Re-capture (or write a one-off back-fill that posts `{labels: ["Memory"], properties: {id, text, embedding, ...}}` to `/v1/graph/nodes`) to retro-fit.
 
 #### `predictRelevance` — AutoML re-ranking with heuristic fallback
 
@@ -197,13 +225,14 @@ await plugin.extensions.trainRelevanceModel(feedback);
 
 Requires at least 10 samples; throws otherwise. Train periodically (cron / on-demand) — the next `predictRelevance` call will detect the model and switch out of heuristic mode.
 
-> **0.1.0 status:** `trainRelevanceModel` validates inputs but throws a clear "not implemented yet" error before calling the gateway, because gateway `v1.6.5.x` rejects inline training rows. Wire your feedback-collection now and the method will start training models the moment you upgrade to `@synapcores/openclaw-memory@0.2.0` (which stages rows in a sibling collection before calling `/v1/automl/train`).
+Under the hood, v0.2.0 stages feedback rows in a SQL table (`openclaw_memory_relevance_training[_<workspace>]`) on the gateway, then calls `/v1/automl/train` with `target: 'score'` and `task: 'regression'`. The table is preserved across calls so feedback accumulates between sessions; clear it manually with `DROP TABLE` (via `client.executeQuery`) if you want a clean restart.
 
-## Roadmap (0.2.0+)
+## Roadmap (0.3.0+)
 
 - **Entity extraction on capture** — parse `@mention` tokens and known-contact names out of incoming text and create `Person` / `Project` graph nodes with `MENTIONS` edges back to the memory.
 - **Tag inference** — auto-classify memories into a configurable tag vocabulary on capture (small classifier or LLM call) so `recallFiltered` queries can use tags out of the box.
 - **`synapcores-import-lancedb` migration script** — read an existing `~/.openclaw/memory/lancedb` store, re-embed if needed, and bulk-load into a SynapCores collection. Ships as a `bin` entry on the package.
+- **Drop the `_getHttpClient` graph-node workaround** once `@synapcores/sdk >0.4.0` fixes `client.graph.nodes.create` to post `{labels: [label]}` instead of `{label}` (the wire shape the gateway's `/v1/graph/nodes` handler expects).
 
 ## Upstream
 

package/dist/cli-metadata.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/plugin-entry").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
+export default _default;
+//# sourceMappingURL=cli-metadata.d.ts.map

package/dist/cli-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-metadata.d.ts","sourceRoot":"","sources":["../cli-metadata.ts"],"names":[],"mappings":";;;;;;;AAMA,wBAeG"}

package/dist/cli-metadata.js

@@ -0,0 +1,22 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+// Lightweight CLI-metadata entry: lets `openclaw plugins` list the `ltm`
+// command + its subcommands without loading the full plugin runtime. The
+// actual command implementation (list / search / stats) is wired via
+// `api.registerCli` inside the main plugin entry (index.ts).
+export default definePluginEntry({
+    id: "memory-synapcores",
+    name: "Memory (SynapCores)",
+    description: "SynapCores-backed long-term memory provider",
+    register(api) {
+        api.registerCli(() => { }, {
+            descriptors: [
+                {
+                    name: "ltm",
+                    description: "Inspect and query SynapCores-backed memory",
+                    hasSubcommands: true,
+                },
+            ],
+        });
+    },
+});
+//# sourceMappingURL=cli-metadata.js.map

package/dist/cli-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-metadata.js","sourceRoot":"","sources":["../cli-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,yEAAyE;AACzE,yEAAyE;AACzE,qEAAqE;AACrE,6DAA6D;AAC7D,eAAe,iBAAiB,CAAC;IAC/B,EAAE,EAAE,mBAAmB;IACvB,IAAI,EAAE,qBAAqB;IAC3B,WAAW,EAAE,6CAA6C;IAC1D,QAAQ,CAAC,GAAG;QACV,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE;YACxB,WAAW,EAAE;gBACX;oBACE,IAAI,EAAE,KAAK;oBACX,WAAW,EAAE,4CAA4C;oBACzD,cAAc,EAAE,IAAI;iBACrB;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF,CAAC,CAAC"}

package/dist/index.d.ts

@@ -9,11 +9,11 @@
  * `recallRelated`, and `predictRelevance`.
  *
  * This is the @synapcores/openclaw-memory drop-in alternative to
- * @openclaw/memory-lancedb. The parity API (recall + capture +
- * auto-recall/auto-capture) plus the three SynapCores-only extensions
- * are all fully wired in 0.1.0.
+ * @openclaw/memory-lancedb. Verified end-to-end against SynapCores
+ * gateway v1.6.5.2-ce. Requires @synapcores/sdk@^0.4.0 — which added
+ * `client.vectorCollection(name)` + `client.createVectorCollection(...)`
+ * and switched API-key auth to `Authorization: Bearer`.
  */
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { type MemoryCategory } from "./config.js";
 export type MemoryEntry = {
     id: string;
@@ -45,10 +45,24 @@ export type RecallFilteredOptions = {
  * memory graph from a given memory ID and returns the neighborhood.
  */
 export type RecallRelatedOptions = {
-    /** Maximum graph hops to traverse (default: 1). */
+    /** Maximum graph hops to traverse (default: 1). Capped at 4 to avoid runaway walks. */
     hops?: number;
-    /** Restrict to specific edge kinds (default: any). Common kinds: `SIMILAR_TO`, `MENTIONS`, `RELATES_TO`. */
+    /**
+     * Restrict to specific edge kinds (default: `["SIMILAR_TO"]`). The
+     * gateway exposes `SIMILAR_TO` as a synthetic edge derived from
+     * cosine similarity over the `embedding` property the plugin writes
+     * onto every captured Memory node. Other edge kinds (e.g. `MENTIONS`,
+     * `RELATES_TO`) are honoured if the caller has populated them.
+     */
     edgeKinds?: string[];
+    /**
+     * Cosine-similarity threshold for synthetic `SIMILAR_TO` edges
+     * (default: 0.5). Higher values return fewer, more closely related
+     * memories. Ignored for non-synthetic edge kinds.
+     */
+    similarityThreshold?: number;
+    /** Maximum results to return (default: 20). */
+    limit?: number;
 };
 /**
  * One result returned from `recallRelated` — the neighbor memory plus the
@@ -98,15 +112,17 @@ export declare function escapeCypherString(value: string): string;
  * methods are exported via `memoryPlugin.extensions` so callers can reach
  * them through the OpenClaw plugin registry.
  *
- * The three SynapCores-only methods use:
- *   - `client.collection(...).vectorSearch({ ..., filter })` for recallFiltered,
- *     forwarding the SQL `WHERE` clause through to the gateway under
+ * The four SynapCores-only methods use:
+ *   - `vectorCollection.search({ ..., filter: { sql } })` for `recallFiltered`,
+ *     forwarding the SQL `WHERE` clause to the gateway under
  *     `filter: { sql: where }`.
- *   - `client.graph.cypher(...)` for recallRelated, walking the `SIMILAR_TO`
- *     edges created automatically at capture-time (plus any `MENTIONS` /
- *     `RELATES_TO` edges added by future entity-extraction tools).
- *   - `client.automl.getModel(...).predict(...)` for predictRelevance, with
+ *   - `client.graph.cypher(...)` for `recallRelated`, walking the synthetic
+ *     `SIMILAR_TO` edges that resolve against `Memory.embedding`.
+ *   - `client.automl.getModel(...).predict(...)` for `predictRelevance`, with
  *     a deterministic heuristic fallback when no model is trained yet.
+ *   - `client.executeQuery(...)` + `client.automl.train(...)` for
+ *     `trainRelevanceModel`, staging feedback rows in a SQL table the
+ *     gateway can `SELECT * FROM` for training.
  */
 export interface MemorySynapCoresExtensions {
     /**
@@ -124,12 +140,14 @@ export interface MemorySynapCoresExtensions {
      * Graph walk from a memory through `SIMILAR_TO` / `MENTIONS` / `RELATES_TO`
      * edges, returning the neighborhood.
      *
-     * @param memoryId - UUID of the source memory.
-     * @param options - Hops and edge-kind filter.
+     * v0.2.0 wires this against the gateway's synthetic-SIMILAR_TO Cypher
+     * syntax (`[:SIMILAR_TO > T]`) which resolves against the `embedding`
+     * property the plugin writes onto every captured Memory node. If a
+     * source memory has not been promoted to a graph node yet (e.g.
+     * `autoLinkSimilar: false`), this returns an empty array.
      *
-     * @remarks `SIMILAR_TO` edges are auto-created at capture time when
-     * `autoLinkSimilar` is true (default). `via` is left empty in 0.1.0;
-     * derive it from a follow-up Cypher walk if you need the full path.
+     * @param memoryId - UUID of the source memory.
+     * @param options - Hops, edge-kind filter, similarity threshold, limit.
      */
     recallRelated(memoryId: string, options?: RecallRelatedOptions): Promise<RelatedMemoryResult[]>;
     /**
@@ -153,89 +171,29 @@ export interface MemorySynapCoresExtensions {
     /**
      * Train (or retrain) the AutoML model used by `predictRelevance`.
      *
+     * v0.2.0 wires this against the staged-collection workflow: feedback
+     * rows are inserted into a SQL table the gateway's AutoML can read
+     * via `SELECT * FROM {table}`, then `/v1/automl/train` is invoked with
+     * `target: 'score'` to fit a regression model. Existing training data
+     * in the staging table is preserved across calls so feedback
+     * accumulates across sessions.
+     *
      * @param feedback - Array of `{ memoryId, queryText, score }` samples.
      *                   Requires at least {@link MIN_TRAINING_SAMPLES} samples;
      *                   throws otherwise.
-     * @returns The id of the trained model.
+     * @returns The id and name of the trained model.
      */
     trainRelevanceModel(feedback: RelevanceFeedback[]): Promise<{
         modelId: string;
         modelName: string;
     }>;
 }
-declare const memoryPlugin: {
+declare const pluginEntry: {
     id: string;
     name: string;
     description: string;
-    kind: "memory";
-    configSchema: {
-        parse(value: unknown): import("./config.js").MemoryConfig;
-        uiHints: {
-            "embedding.apiKey": {
-                label: string;
-                sensitive: boolean;
-                placeholder: string;
-                help: string;
-            };
-            "embedding.model": {
-                label: string;
-                placeholder: string;
-                help: string;
-            };
-            "synapcores.host": {
-                label: string;
-                placeholder: string;
-                help: string;
-            };
-            "synapcores.port": {
-                label: string;
-                placeholder: string;
-                help: string;
-            };
-            "synapcores.apiKey": {
-                label: string;
-                sensitive: boolean;
-                placeholder: string;
-                help: string;
-            };
-            "synapcores.useHttps": {
-                label: string;
-                advanced: boolean;
-                help: string;
-            };
-            collection: {
-                label: string;
-                placeholder: string;
-                advanced: boolean;
-                help: string;
-            };
-            graph: {
-                label: string;
-                placeholder: string;
-                advanced: boolean;
-                help: string;
-            };
-            autoCapture: {
-                label: string;
-                help: string;
-            };
-            autoRecall: {
-                label: string;
-                help: string;
-            };
-            autoLinkSimilar: {
-                label: string;
-                advanced: boolean;
-                help: string;
-            };
-            workspace: {
-                label: string;
-                advanced: boolean;
-                help: string;
-            };
-        };
-    };
-    register(api: OpenClawPluginApi): void;
-};
-export default memoryPlugin;
+    configSchema: import("openclaw/plugin-sdk/core").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
+export default pluginEntry;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAO7D,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,aAAa,CAAC;AAMrB,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,wGAAwG;IACxG,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4GAA4G;IAC5G,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,EAAE,CAAC;CACf,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAodF;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AA2DD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;OASG;IACH,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAE9E;;;;;;;;;;OAUG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAEhG;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CACd,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,WAAW,EAAE,GACxB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAEpC;;;;;;;OAOG;IACH,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrG;AAsKD,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOF,iBAAiB;CAqbhC,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAUH,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,aAAa,CAAC;AAMrB,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,wGAAwG;IACxG,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,uFAAuF;IACvF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,EAAE,CAAC;CACf,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsfF;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAuGD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;;;OASG;IACH,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAE9E;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAEhG;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CACd,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,WAAW,EAAE,GACxB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAEpC;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrG;AAkwBD,QAAA,MAAM,WAAW;;;;;;yIAAkC,CAAC;AAEpD,eAAe,WAAW,CAAC"}