triggerix-editor-preset-war3 0.0.0 → 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 imba97 <https://github.com/imba97>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,412 @@
+'use strict';
+
+const editor = require('@triggerix/editor');
+
+function parseTemplate(template, slots, slotValues) {
+  const segments = [];
+  const regex = /\$\{(\w+)\}/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    if (match.index > lastIndex) {
+      segments.push({ type: "text", content: template.slice(lastIndex, match.index) });
+    }
+    const key = match[1];
+    const slotDef = slots?.[key];
+    if (slotDef) {
+      const entry = slotValues?.[key];
+      segments.push({
+        type: "slot",
+        key,
+        label: slotDef.label,
+        tools: slotDef.tools,
+        value: entry?.value ?? null,
+        entry: entry ?? void 0
+      });
+    } else {
+      segments.push({ type: "text", content: match[0] });
+    }
+    lastIndex = regex.lastIndex;
+  }
+  if (lastIndex < template.length) {
+    segments.push({ type: "text", content: template.slice(lastIndex) });
+  }
+  return segments;
+}
+
+function buildDescriptor(def, slotValues) {
+  return {
+    id: def.id,
+    segments: parseTemplate(def.template, def.slots, slotValues)
+  };
+}
+function getEventDescriptor(registry, id, slotValues) {
+  const def = registry.getEvent(id);
+  return def ? buildDescriptor(def, slotValues) : null;
+}
+function getActionDescriptor(registry, id, slotValues) {
+  const def = registry.getAction(id);
+  return def ? buildDescriptor(def, slotValues) : null;
+}
+function getConditionDescriptor(registry, id, slotValues) {
+  const def = registry.getCondition(id);
+  return def ? buildDescriptor(def, slotValues) : null;
+}
+function getToolDescriptor(registry, toolName, slotValues) {
+  const def = registry.getTool(toolName);
+  if (!def)
+    return null;
+  if (def.kind === "leaf") {
+    return {
+      kind: "leaf",
+      name: toolName,
+      label: def.label,
+      input: def.input
+    };
+  }
+  return {
+    kind: "composite",
+    name: toolName,
+    label: def.label,
+    segments: parseTemplate(def.template, def.slots, slotValues)
+  };
+}
+function getSlotToolDescriptors(registry, slotDef) {
+  return slotDef.tools.map((name) => getToolDescriptor(registry, name)).filter((d) => d !== null);
+}
+
+class War3Registry extends editor.BaseRegistry {
+  tools = /* @__PURE__ */ new Map();
+  registerTool(name, def) {
+    this.tools.set(name, def);
+  }
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  getTools() {
+    return new Map(this.tools);
+  }
+  getValueSources(valueType) {
+    let conditions = this.getConditions();
+    let tools = this.getTools();
+    if (valueType) {
+      conditions = conditions.filter((c) => c.type === valueType);
+      tools = new Map([...tools.entries()].filter(([_, t]) => t.type === valueType));
+    }
+    return { conditions, tools };
+  }
+}
+
+function resolveSlotValue(entry, registry) {
+  if (!entry.tool)
+    return void 0;
+  const toolDef = registry.getTool(entry.tool);
+  if (!toolDef)
+    return void 0;
+  if (toolDef.kind === "leaf") {
+    return toolDef.resolve(entry.value);
+  }
+  const resolvedSubSlots = {};
+  if (entry.subSlots) {
+    for (const [key, subEntry] of Object.entries(entry.subSlots)) {
+      resolvedSubSlots[key] = resolveSlotValue(subEntry, registry);
+    }
+  }
+  return toolDef.resolve(resolvedSubSlots);
+}
+function resolveItemParams(slotValues, registry) {
+  const params = {};
+  let hasParams = false;
+  for (const [key, entry] of Object.entries(slotValues)) {
+    const resolved = resolveSlotValue(entry, registry);
+    if (resolved !== void 0) {
+      params[key] = resolved;
+      hasParams = true;
+    }
+  }
+  return hasParams ? params : void 0;
+}
+function serializeItems(items, registry) {
+  return items.map((item) => {
+    const params = resolveItemParams(item.slotValues, registry);
+    const action = { type: item.id };
+    if (params) {
+      action.params = params;
+    }
+    return action;
+  });
+}
+function generateRuleId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `rule-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function toRule(state, registry, ruleId) {
+  const eventParams = state.event ? resolveItemParams(state.event.slotValues, registry) : void 0;
+  const event = {
+    type: state.event?.id ?? "",
+    ...eventParams ? { payload: eventParams } : {}
+  };
+  const actions = serializeItems(state.actions, registry);
+  const rule = {
+    id: ruleId ?? generateRuleId(),
+    event,
+    actions
+  };
+  if (state.conditions.length > 0) {
+    rule.conditions = {
+      type: "and",
+      conditions: serializeItems(state.conditions, registry)
+    };
+  }
+  return rule;
+}
+
+const INITIAL_STATE = {
+  event: null,
+  conditions: [],
+  actions: []
+};
+class War3EditorStateManager extends editor.ObservableState {
+  constructor() {
+    super({ ...INITIAL_STATE });
+  }
+  // --- Event ---
+  setEvent(id) {
+    this.setState((s) => ({ ...s, event: { id, slotValues: {} } }));
+  }
+  clearEvent() {
+    this.setState((s) => ({ ...s, event: null }));
+  }
+  setEventSlot(key, entry) {
+    this.setState((s) => {
+      if (!s.event)
+        return s;
+      return {
+        ...s,
+        event: {
+          ...s.event,
+          slotValues: { ...s.event.slotValues, [key]: entry }
+        }
+      };
+    });
+  }
+  // --- Actions ---
+  addAction(id) {
+    this.setState((s) => ({
+      ...s,
+      actions: [...s.actions, { id, slotValues: {} }]
+    }));
+  }
+  removeAction(index) {
+    this.setState((s) => ({
+      ...s,
+      actions: s.actions.filter((_, i) => i !== index)
+    }));
+  }
+  moveAction(from, to) {
+    this.setState((s) => {
+      const actions = [...s.actions];
+      const [moved] = actions.splice(from, 1);
+      actions.splice(to, 0, moved);
+      return { ...s, actions };
+    });
+  }
+  setActionSlot(actionIndex, key, entry) {
+    this.setItemSlot("actions", actionIndex, key, entry);
+  }
+  // --- Conditions ---
+  addCondition(id) {
+    this.setState((s) => ({
+      ...s,
+      conditions: [...s.conditions, { id, slotValues: {} }]
+    }));
+  }
+  removeCondition(index) {
+    this.setState((s) => ({
+      ...s,
+      conditions: s.conditions.filter((_, i) => i !== index)
+    }));
+  }
+  setConditionSlot(conditionIndex, key, entry) {
+    this.setItemSlot("conditions", conditionIndex, key, entry);
+  }
+  // --- Reset ---
+  reset() {
+    this.setState(() => ({ ...INITIAL_STATE }));
+  }
+  // --- Helpers ---
+  setItemSlot(field, index, key, entry) {
+    this.setState((s) => {
+      const items = [...s[field]];
+      const item = items[index];
+      if (!item)
+        return s;
+      items[index] = { ...item, slotValues: { ...item.slotValues, [key]: entry } };
+      return { ...s, [field]: items };
+    });
+  }
+}
+
+function createWar3Editor() {
+  const registry = new War3Registry();
+  const stateManager = new War3EditorStateManager();
+  const editor = {
+    // --- Editor 接口 ---
+    getState: () => stateManager.getState(),
+    onChange: (listener) => stateManager.onChange(listener),
+    toRule: (ruleId) => toRule(stateManager.getState(), registry, ruleId),
+    reset: () => stateManager.reset(),
+    dispose: () => stateManager.dispose(),
+    // --- 注册 ---
+    registerEvent: (def) => registry.registerEvent(def),
+    registerAction: (def) => registry.registerAction(def),
+    registerCondition: (def) => registry.registerCondition(def),
+    registerTool: (name, def) => registry.registerTool(name, def),
+    // --- 注册表访问 ---
+    getRegistry: () => registry,
+    // --- 查询 ---
+    getAvailableEvents: () => registry.getEvents(),
+    getAvailableActions: () => registry.getActions(),
+    getAvailableConditions: () => registry.getConditions(),
+    // --- 描述符 ---
+    getEventDescriptor: () => {
+      const state = stateManager.getState();
+      if (!state.event)
+        return null;
+      return getEventDescriptor(registry, state.event.id, state.event.slotValues);
+    },
+    getActionDescriptor: (index) => {
+      const state = stateManager.getState();
+      const action = state.actions[index];
+      if (!action)
+        return null;
+      return getActionDescriptor(registry, action.id, action.slotValues);
+    },
+    getConditionDescriptor: (index) => {
+      const state = stateManager.getState();
+      const condition = state.conditions[index];
+      if (!condition)
+        return null;
+      return getConditionDescriptor(registry, condition.id, condition.slotValues);
+    },
+    getToolDescriptor: (toolName, slotValues) => getToolDescriptor(registry, toolName, slotValues),
+    getSlotTools: (slotDef) => getSlotToolDescriptors(registry, slotDef),
+    // --- 状态操作 ---
+    setEvent: (id) => stateManager.setEvent(id),
+    clearEvent: () => stateManager.clearEvent(),
+    setEventSlot: (key, entry) => stateManager.setEventSlot(key, entry),
+    addAction: (id) => stateManager.addAction(id),
+    removeAction: (index) => stateManager.removeAction(index),
+    moveAction: (from, to) => stateManager.moveAction(from, to),
+    setActionSlot: (actionIndex, key, entry) => stateManager.setActionSlot(actionIndex, key, entry),
+    addCondition: (id) => stateManager.addCondition(id),
+    removeCondition: (index) => stateManager.removeCondition(index),
+    setConditionSlot: (conditionIndex, key, entry) => stateManager.setConditionSlot(conditionIndex, key, entry),
+    // --- 值来源查询 ---
+    getValueSources: (valueType) => registry.getValueSources(valueType),
+    // --- Preset ---
+    applyPreset: (preset) => {
+      preset.setup(editor);
+    },
+    // --- 序列化工具 ---
+    resolveSlotValue: (entry) => resolveSlotValue(entry, registry)
+  };
+  return editor;
+}
+
+function valueEquals(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+function stringifyValue(v) {
+  if (v == null)
+    return "";
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function resolveSlotDisplayText(entry, registry, fallbackLabel) {
+  if (!entry?.tool)
+    return fallbackLabel;
+  const toolDef = registry.getTool(entry.tool);
+  if (!toolDef)
+    return fallbackLabel;
+  if (toolDef.kind === "leaf") {
+    if (entry.value == null || entry.value === "")
+      return fallbackLabel;
+    if (toolDef.input.type === "select") {
+      const opt = toolDef.input.options?.find((o) => valueEquals(o.value, entry.value));
+      if (opt)
+        return opt.label;
+    }
+    return stringifyValue(entry.value);
+  }
+  const segments = parseTemplate(toolDef.template, toolDef.slots, entry.subSlots ?? {});
+  return segments.map((seg) => {
+    if (seg.type === "text")
+      return seg.content;
+    if (seg.type === "slot") {
+      const subEntry = entry.subSlots?.[seg.key];
+      return resolveSlotDisplayText(subEntry ?? null, registry, seg.label);
+    }
+    return "";
+  }).join("");
+}
+
+function defineLeafTool(def) {
+  return { ...def, kind: "leaf" };
+}
+function defineCompositeTool(def) {
+  return { ...def, kind: "composite" };
+}
+function defineCondition(def) {
+  return def;
+}
+
+function defineWar3Preset(options) {
+  return {
+    name: options.name,
+    setup(editor) {
+      options.events?.forEach((def) => editor.registerEvent(def));
+      options.actions?.forEach((def) => editor.registerAction(def));
+      options.conditions?.forEach((def) => editor.registerCondition(def));
+      if (options.tools) {
+        for (const [name, def] of Object.entries(options.tools)) {
+          editor.registerTool(name, def);
+        }
+      }
+    }
+  };
+}
+
+exports.War3EditorStateManager = War3EditorStateManager;
+exports.War3Registry = War3Registry;
+exports.createWar3Editor = createWar3Editor;
+exports.defineCompositeTool = defineCompositeTool;
+exports.defineCondition = defineCondition;
+exports.defineLeafTool = defineLeafTool;
+exports.defineWar3Preset = defineWar3Preset;
+exports.getActionDescriptor = getActionDescriptor;
+exports.getConditionDescriptor = getConditionDescriptor;
+exports.getEventDescriptor = getEventDescriptor;
+exports.getSlotToolDescriptors = getSlotToolDescriptors;
+exports.getToolDescriptor = getToolDescriptor;
+exports.parseTemplate = parseTemplate;
+exports.resolveSlotDisplayText = resolveSlotDisplayText;
+exports.resolveSlotValue = resolveSlotValue;
+exports.toRule = toRule;

package/dist/index.d.cts

@@ -0,0 +1,239 @@
+import { BaseItemDef, BaseRegistry, Editor, Preset, ObservableState } from '@triggerix/editor';
+export { BaseItemDef, Preset } from '@triggerix/editor';
+import { Value, Rule } from '@triggerix/core';
+
+interface SlotDef {
+    label: string;
+    tools: string[];
+}
+interface SlotValueEntry {
+    tool: string | null;
+    value: unknown;
+    subSlots?: Record<string, SlotValueEntry>;
+}
+interface LeafToolInput<TValue = unknown> {
+    type: 'text' | 'number' | 'select';
+    placeholder?: string;
+    options?: Array<{
+        value: TValue;
+        label: string;
+    }>;
+}
+interface LeafToolDef<TInput = unknown, TOutput = unknown> {
+    kind: 'leaf';
+    type?: string;
+    label: string;
+    input: LeafToolInput<TInput>;
+    resolve: (input: TInput) => TOutput;
+}
+interface CompositeToolDef<TSlotValues extends Record<string, unknown> = Record<string, unknown>, TOutput = unknown> {
+    kind: 'composite';
+    type?: string;
+    label: string;
+    template: string;
+    slots: Record<keyof TSlotValues & string, SlotDef>;
+    resolve: (slotValues: TSlotValues) => TOutput;
+}
+type ToolDef = LeafToolDef<any, any> | CompositeToolDef<any, any>;
+interface War3EventDef extends BaseItemDef {
+    template: string;
+    slots?: Record<string, SlotDef>;
+}
+interface War3ActionDef extends BaseItemDef {
+    template: string;
+    slots?: Record<string, SlotDef>;
+}
+interface War3ConditionDef<TSlotValues extends Record<string, unknown> = Record<string, unknown>> extends BaseItemDef {
+    template: string;
+    slots?: Record<string, SlotDef>;
+    resolve?: (slotValues: TSlotValues) => unknown;
+}
+type Segment = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'slot';
+    key: string;
+    label: string;
+    tools: string[];
+    value: unknown;
+    entry?: SlotValueEntry;
+};
+interface ItemDescriptor {
+    id: string;
+    segments: Segment[];
+}
+interface LeafToolDescriptor {
+    kind: 'leaf';
+    name: string;
+    label: string;
+    input: LeafToolInput;
+}
+interface CompositeToolDescriptor {
+    kind: 'composite';
+    name: string;
+    label: string;
+    segments: Segment[];
+}
+type ToolDescriptor = LeafToolDescriptor | CompositeToolDescriptor;
+interface ItemState {
+    id: string;
+    slotValues: Record<string, SlotValueEntry>;
+}
+interface War3EditorState {
+    event: ItemState | null;
+    conditions: ItemState[];
+    actions: ItemState[];
+}
+interface War3PresetOptions {
+    name: string;
+    events?: War3EventDef[];
+    actions?: War3ActionDef[];
+    conditions?: War3ConditionDef[];
+    tools?: Record<string, ToolDef>;
+}
+
+/**
+ * War3 注册表 - 继承 BaseRegistry，增加 Tool 注册能力
+ */
+declare class War3Registry extends BaseRegistry<War3EventDef, War3ActionDef, War3ConditionDef> {
+    private tools;
+    registerTool(name: string, def: ToolDef): void;
+    getTool(name: string): ToolDef | undefined;
+    getTools(): Map<string, ToolDef>;
+    getValueSources(valueType?: string): {
+        conditions: War3ConditionDef[];
+        tools: Map<string, ToolDef>;
+    };
+}
+
+interface War3Editor extends Editor<War3EditorState> {
+    registerEvent: (def: War3EventDef) => void;
+    registerAction: (def: War3ActionDef) => void;
+    registerCondition: (def: War3ConditionDef) => void;
+    registerTool: (name: string, def: ToolDef) => void;
+    getRegistry: () => War3Registry;
+    getAvailableEvents: () => War3EventDef[];
+    getAvailableActions: () => War3ActionDef[];
+    getAvailableConditions: () => War3ConditionDef[];
+    getEventDescriptor: () => ItemDescriptor | null;
+    getActionDescriptor: (actionIndex: number) => ItemDescriptor | null;
+    getConditionDescriptor: (conditionIndex: number) => ItemDescriptor | null;
+    getToolDescriptor: (toolName: string, slotValues?: Record<string, SlotValueEntry>) => ToolDescriptor | null;
+    getSlotTools: (slotDef: SlotDef) => ToolDescriptor[];
+    setEvent: (id: string) => void;
+    clearEvent: () => void;
+    setEventSlot: (key: string, entry: SlotValueEntry) => void;
+    addAction: (id: string) => void;
+    removeAction: (index: number) => void;
+    moveAction: (from: number, to: number) => void;
+    setActionSlot: (actionIndex: number, key: string, entry: SlotValueEntry) => void;
+    addCondition: (id: string) => void;
+    removeCondition: (index: number) => void;
+    setConditionSlot: (conditionIndex: number, key: string, entry: SlotValueEntry) => void;
+    getValueSources: (valueType?: string) => {
+        conditions: War3ConditionDef[];
+        tools: Map<string, ToolDef>;
+    };
+    applyPreset: (preset: Preset<War3Editor>) => void;
+    resolveSlotValue: (entry: SlotValueEntry) => unknown;
+}
+declare function createWar3Editor(): War3Editor;
+
+declare function getEventDescriptor(registry: War3Registry, id: string, slotValues?: Record<string, SlotValueEntry>): ItemDescriptor | null;
+declare function getActionDescriptor(registry: War3Registry, id: string, slotValues?: Record<string, SlotValueEntry>): ItemDescriptor | null;
+declare function getConditionDescriptor(registry: War3Registry, id: string, slotValues?: Record<string, SlotValueEntry>): ItemDescriptor | null;
+declare function getToolDescriptor(registry: War3Registry, toolName: string, slotValues?: Record<string, SlotValueEntry>): ToolDescriptor | null;
+declare function getSlotToolDescriptors(registry: War3Registry, slotDef: SlotDef): ToolDescriptor[];
+
+/**
+ * 递归解析 SlotValueEntry 为人类可读的展示文本
+ *
+ * - 如果 entry 为 null/undefined 或未选择 tool，返回 fallbackLabel（slot 占位文案）
+ * - 如果 tool 为 leaf：
+ *   - select 类型：尝试匹配 options 找到对应 label（支持对象值的深比较）
+ *   - 其它类型：返回 value 的字符串形式
+ *   - 若 value 为空：返回 fallbackLabel
+ * - 如果 tool 为 composite：使用 tool 的 template 递归展开
+ */
+declare function resolveSlotDisplayText(entry: SlotValueEntry | null | undefined, registry: War3Registry, fallbackLabel: string): string;
+
+/**
+ * Type-safe LeafTool definition.
+ * Input type comes from the resolve callback annotation; output is inferred.
+ */
+declare function defineLeafTool<TInput, TOutput>(def: {
+    type?: string;
+    label: string;
+    input: LeafToolInput<TInput>;
+    resolve: (input: TInput) => TOutput;
+}): {
+    kind: "leaf";
+    type?: string;
+    label: string;
+    input: LeafToolInput<TInput>;
+    resolve: (input: TInput) => TOutput;
+};
+/**
+ * Type-safe CompositeTool definition.
+ * Slot value types come from the resolve callback; slot keys are validated against it.
+ */
+declare function defineCompositeTool<TSlotValues extends Record<string, unknown>, TOutput>(def: {
+    type?: string;
+    label: string;
+    template: string;
+    slots: Record<keyof TSlotValues & string, SlotDef>;
+    resolve: (slotValues: TSlotValues) => TOutput;
+}): CompositeToolDef<TSlotValues, TOutput>;
+/**
+ * Type-safe Condition definition.
+ */
+declare function defineCondition<TSlotValues extends Record<string, unknown> = Record<string, unknown>>(def: Omit<War3ConditionDef<TSlotValues>, 'resolve'> & {
+    resolve?: (slotValues: TSlotValues) => unknown;
+}): War3ConditionDef;
+
+/**
+ * 解析模板字符串为 Segment 数组
+ * 模板格式: "普通文本${slotKey}更多文本"
+ */
+declare function parseTemplate(template: string, slots?: Record<string, SlotDef>, slotValues?: Record<string, SlotValueEntry>): Segment[];
+
+declare function defineWar3Preset(options: War3PresetOptions): Preset<War3Editor>;
+
+/**
+ * Recursively resolve a single slot value.
+ */
+declare function resolveSlotValue(entry: SlotValueEntry, registry: War3Registry): Value | undefined;
+/**
+ * Serialize editor state into a standard Rule JSON.
+ *
+ * Output shape (compatible with @triggerix/core):
+ *   {
+ *     id, event: { type, payload? }, conditions?: { type:'and', conditions:[...] },
+ *     actions: [{ type, params? }]
+ *   }
+ */
+declare function toRule(state: War3EditorState, registry: War3Registry, ruleId?: string): Rule;
+
+/**
+ * War3 编辑器状态管理
+ * 继承 ObservableState，提供模板模式特有的状态操作
+ */
+declare class War3EditorStateManager extends ObservableState<War3EditorState> {
+    constructor();
+    setEvent(id: string): void;
+    clearEvent(): void;
+    setEventSlot(key: string, entry: SlotValueEntry): void;
+    addAction(id: string): void;
+    removeAction(index: number): void;
+    moveAction(from: number, to: number): void;
+    setActionSlot(actionIndex: number, key: string, entry: SlotValueEntry): void;
+    addCondition(id: string): void;
+    removeCondition(index: number): void;
+    setConditionSlot(conditionIndex: number, key: string, entry: SlotValueEntry): void;
+    reset(): void;
+    private setItemSlot;
+}
+
+export { War3EditorStateManager, War3Registry, createWar3Editor, defineCompositeTool, defineCondition, defineLeafTool, defineWar3Preset, getActionDescriptor, getConditionDescriptor, getEventDescriptor, getSlotToolDescriptors, getToolDescriptor, parseTemplate, resolveSlotDisplayText, resolveSlotValue, toRule };
+export type { CompositeToolDef, CompositeToolDescriptor, ItemDescriptor, ItemState, LeafToolDef, LeafToolDescriptor, LeafToolInput, Segment, SlotDef, SlotValueEntry, ToolDef, ToolDescriptor, War3ActionDef, War3ConditionDef, War3Editor, War3EditorState, War3EventDef, War3PresetOptions };